claude-mem-lite 3.79.0 → 3.80.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.79.0",
+      "version": "3.80.0",
       "source": "./",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.79.0",
+  "version": "3.80.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).",
   "author": {
     "name": "sdsrss"

package/lib/citation-tracker.mjs

@@ -20,9 +20,65 @@ import { readTranscriptEntries } from './transcript-scan.mjs';
 import { TASK_IMPERATIVE_PREFIX } from './task-imperative.mjs';
 
 import { DAY_MS } from './time-constants.mjs';
+/**
+ * The ONE caliber for an observation id appearing in text. Bounded to 1-7 digits to
+ * skip URL fragments, markdown anchors, etc.
+ *
+ * Exported because the offline benchmarks re-derive production's numbers from the same
+ * transcripts, and each had hand-copied its own: `benchmark/cite-recall.mjs` scanned
+ * citations with `{2,6}` while its OWN injected denominator used `{1,7}`, and
+ * `efficacy-observational.mjs` / `adoption-replay.mjs` had a third and fourth caliber
+ * (`{2,6}` / `{2,7}`). A denominator wider than its numerator counts an id as
+ * injected-never-cited that the numerator structurally cannot see, which biases the
+ * measured cite-rate DOWN — and nothing errors when it happens.
+ *
+ * Measured live impact at the time this was unified (2026-08-24, 3692 rows, ids 1..10834):
+ * exactly ZERO. The only ids outside `{2,6}` are four 1-digit rows, and all four have
+ * injection_count = 0, so they never entered a denominator; there are no 7-digit ids.
+ * This is a latent-class fix, not a correction to any published number — do not
+ * re-attribute past readings to it.
+ */
+export const OBS_ID_DIGITS = '\\d{1,7}';
+
+/**
+ * A fresh global matcher for a bare `#NN` citation.
+ *
+ * Returned fresh per call rather than shared: a `/g` regex carries `lastIndex`, so one
+ * exported instance reused by two scanners silently starts mid-string in whichever one
+ * runs second.
+ */
+export function citationIdRe() {
+  return new RegExp(`#(${OBS_ID_DIGITS})\\b`, 'g');
+}
+
+/**
+ * Caliber for an id scraped from UNANCHORED text that is then treated as an INJECTED
+ * (denominator) set.
+ *
+ * `citationIdRe()` above is a NUMERATOR caliber. On the numerator side a spurious `#1`
+ * costs nothing, because a cited id only counts once it intersects an injected set that
+ * WAS anchored — every injected-side extractor in this module matches a row shape
+ * (`INJECTED_ROW_RE`, `FYI_LINE_ID_RE`, `UPS_ID_RE`, `SUBAGENT_INJECT_ID_RE`). On the
+ * denominator side nothing anchors it, so a prose `#1` is a false positive by
+ * construction — it inflates "injected, never cited" and biases the measured rate DOWN.
+ *
+ * The v3.80.0 pre-tag review caught this concretely: pointing
+ * `benchmark/adoption-replay.mjs` at `citationIdRe()` pulled `#1` and `#2` out of a
+ * subagent prompt discussing fixture rows ("with `#1` superseded by `#2` …") straight into
+ * `injectedIds`, on a real transcript. Excluding 1-digit ids costs nothing measurable —
+ * the four 1-digit rows in the live corpus have `injection_count = 0` — and removes the
+ * commonest prose collision.
+ *
+ * This is a stopgap for a caliber symptom, NOT a fix for the cause. The cause is that
+ * adoption-replay scrapes a whole prompt where it should match injected ROWS, the way
+ * production does. Do not reach for this anywhere else; anchor instead.
+ */
+export function unanchoredInjectedIdRe() {
+  return new RegExp('#(\\d{2,7})\\b', 'g');
+}
+
 // `#123` / `#45678` at a word boundary — matches the CLAUDE.md cite pattern.
-// Bounded to 1-7 digits to skip URL fragments, markdown anchors, etc.
-const CITATION_RE = /#(\d{1,7})\b/g;
+const CITATION_RE = citationIdRe();
 
 /**
  * Parse a Claude Code transcript .jsonl and extract unique observation IDs
@@ -147,7 +203,7 @@ export function bumpCitationAccess(db, ids, project) {
 // Matches a pre-tool-recall / error-recall lesson line: `  #NN [type] body...`.
 // Bounded type list mirrors observations.type CHECK + the events table's allowed
 // event_type values these surfaces can emit.
-const INJECTED_RE = /#(\d{1,7})\s+\[(bugfix|decision|change|discovery|feature|refactor|lesson)\]/g;
+const INJECTED_RE = new RegExp(`#(${OBS_ID_DIGITS})\\s+\\[(bugfix|decision|change|discovery|feature|refactor|lesson)\\]`, 'g');
 // Line-anchored variant: a genuine injected ROW begins (after its short indent) with
 // `#NN [type]`. pre-tool-recall AND error-recall inline a lesson_learned body into the
 // row; a body that quotes another obs ("same as #1234 [decision]") must NOT count as
@@ -217,7 +273,7 @@ function eachHookAttachment(transcriptPath, fn, opts = {}) {
 // like "see (#999)" doesn't pollute the injected set (would streak-uncite an
 // obs we never actually displayed as a top-level entry).
 const UPS_LINE_PREFIX = '- [';
-const UPS_ID_RE = /\(#(\d{1,7})\)/g;
+const UPS_ID_RE = new RegExp(`\\(#(${OBS_ID_DIGITS})\\)`, 'g');
 // Quote-normalized (see normalizeHookCommand): real recorded command is
 // `node "/abs/hook.mjs" user-prompt` → normalized to `node /abs/hook.mjs user-prompt`.
 const UPS_COMMAND_SUFFIX = 'hook.mjs user-prompt';
@@ -230,7 +286,7 @@ const UPS_COMMAND_SUFFIX = 'hook.mjs user-prompt';
 const FYI_HEADER = '[mem] FYI — Related memories';
 // Anchored at line start so `P#NN` past-question rows (user_prompts, different id
 // space) and any `#NN` inside lesson text are NOT matched.
-const FYI_LINE_ID_RE = /^#(\d{1,7})\s/;
+const FYI_LINE_ID_RE = new RegExp(`^#(${OBS_ID_DIGITS})\\s`);
 
 /**
  * The injection FACES memory can reach the model through, as stored in
@@ -569,7 +625,7 @@ export function unionSurfaces(bySurface) {
 const SUBAGENT_INJECT_MARKER = /surfaced by your operator's claude-mem-lite/;
 // Row-anchored to the `#NN — ` tag so a #NN quoted inside the lesson body does NOT enter
 // the injected set — same discipline as INJECTED_ROW_RE for the attachment surfaces.
-const SUBAGENT_INJECT_ID_RE = /^\s{0,4}#(\d{1,7})\s+—/;
+const SUBAGENT_INJECT_ID_RE = new RegExp(`^\\s{0,4}#(${OBS_ID_DIGITS})\\s+—`);
 
 /**
  * Extract observation ids injected into a subagent's PROMPT by pre-agent-inject.js

package/lib/cite-back-hint.mjs

@@ -15,6 +15,9 @@ import { basename, join } from 'path';
 import { readFileSync } from 'fs';
 import { readTranscriptEntries } from './transcript-scan.mjs';
 import { EDIT_TOOLS } from '../utils.mjs';
+// One caliber for `#NN`. citation-tracker.mjs does NOT import this module, so the edge
+// is acyclic.
+import { citationIdRe } from './citation-tracker.mjs';
 
 const MAX_FILES = 2;
 
@@ -269,7 +272,9 @@ export function loadCiteBackForEpisode(episode, runtimeDir) {
 // #NN. The Stop handler unions these into the cited set passed to
 // applyCitationDecay (lib/citation-tracker.mjs), so acting on a lesson promotes
 // it and lifts the project's adoption rate. Returns an empty set on missing path.
-const CITE_BACK_ID_RE = /#(\d{1,7})\b/g;
+// The ids collected here are unioned into the SAME cited set applyCitationDecay reads,
+// so this caliber must be the extractor's own — imported, not a sixth hand-copy.
+const CITE_BACK_ID_RE = citationIdRe();
 
 export function extractCiteBackSignals(transcriptPath) {
   const ids = new Set();

package/lib/hook-stdout.mjs

@@ -27,6 +27,40 @@
 let parts = [];
 let queuedEvent = null;
 let systemParts = [];
+let queuedInput = null;
+
+/** Emit the noisy drop notice. stderr is safe: the host never parses it as the envelope. */
+function warnDrop(deps, msg) {
+  const warn = deps.warn || ((m) => { try { process.stderr.write(m); } catch { /* never block on a warning */ } });
+  warn(msg);
+}
+
+/**
+ * Claim this process's single hookEventName, or refuse the contribution.
+ *
+ * Mixed event names cannot be merged — Claude Code throws when
+ * hookSpecificOutput.hookEventName does not match the event it dispatched.
+ * In practice one process serves one event; keep the first and drop the
+ * stragglers rather than emit an envelope the host rejects outright.
+ *
+ * The drop is NOISY on purpose. It is unreachable today (all call sites are
+ * event-consistent), but flushEpisode's hookEventName DEFAULTS to 'PostToolUse',
+ * so a future caller that omits the argument would both mis-tag its receipt and
+ * have it swallowed without a trace. Silently vanishing work is this repo's
+ * most-repeated defect class.
+ *
+ * @returns {boolean} true when the caller may proceed.
+ */
+function claimEvent(hookEventName, what, deps) {
+  if (queuedEvent && queuedEvent !== hookEventName) {
+    warnDrop(deps, `[claude-mem-lite] hook-stdout: dropped a ${hookEventName} ${what} — this process `
+      + `already queued ${queuedEvent}, and one envelope carries exactly one hookEventName. `
+      + 'This is a wiring bug: the contribution is lost.\n');
+    return false;
+  }
+  queuedEvent = hookEventName;
+  return true;
+}
 
 /**
  * Queue a contribution to this process's single stdout envelope.
@@ -40,26 +74,40 @@ export function queueHookContext(hookEventName, text, deps = {}) {
   if (!hookEventName) return;
   const body = String(text ?? '').trim();
   if (!body) return;
-  // Mixed event names cannot be merged — Claude Code throws when
-  // hookSpecificOutput.hookEventName does not match the event it dispatched.
-  // In practice one process serves one event; keep the first and drop the
-  // stragglers rather than emit an envelope the host rejects outright.
-  //
-  // The drop is NOISY on purpose. It is unreachable today (all call sites are
-  // event-consistent), but flushEpisode's hookEventName DEFAULTS to 'PostToolUse',
-  // so a future caller that omits the argument would both mis-tag its receipt and
-  // have it swallowed without a trace. Silently vanishing work is this repo's
-  // most-repeated defect class; stderr is safe here because the host never parses it
-  // as the envelope.
-  if (queuedEvent && queuedEvent !== hookEventName) {
-    const warn = deps.warn || ((m) => { try { process.stderr.write(m); } catch { /* never block on a warning */ } });
-    warn(`[claude-mem-lite] hook-stdout: dropped a ${hookEventName} contribution — this process `
-      + `already queued ${queuedEvent}, and one envelope carries exactly one hookEventName. `
-      + 'This is a wiring bug: the contribution is lost.\n');
+  if (!claimEvent(hookEventName, 'contribution', deps)) return;
+  parts.push(body);
+}
+
+/**
+ * Queue a `hookSpecificOutput.updatedInput` — a REPLACEMENT of the tool's input,
+ * not a contribution to it. PreToolUse is the only event whose schema carries one
+ * (2.1.241 bundle: `{hookEventName: "PreToolUse", permissionDecision?,
+ * permissionDecisionReason?, updatedInput?, additionalContext?}`), and that same
+ * schema is why this belongs here rather than in its own writer: a mutation and a
+ * context line may ride ONE envelope, so a hook that grew both would otherwise
+ * emit two documents and lose both (the v3.70.0 degradation this module exists for).
+ *
+ * FIRST writer wins, and a second is dropped noisily. Unlike additionalContext
+ * there is no merge: two callers each hand over a whole tool_input, so last-wins
+ * would silently discard the earlier mutation — the same vanishing-work shape
+ * claimEvent guards against.
+ *
+ * @param {string} hookEventName Event name for hookSpecificOutput.
+ * @param {object} input Replacement tool_input; non-objects and null are ignored.
+ * @param {{warn?: (msg: string) => void}} [deps]
+ * @returns {void}
+ */
+export function queueHookUpdatedInput(hookEventName, input, deps = {}) {
+  if (!hookEventName) return;
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return;
+  if (!claimEvent(hookEventName, 'updatedInput', deps)) return;
+  if (queuedInput) {
+    warnDrop(deps, '[claude-mem-lite] hook-stdout: dropped a second updatedInput — one envelope '
+      + 'replaces the tool input exactly once, and merging two whole inputs is not defined. '
+      + 'This is a wiring bug: the second mutation is lost.\n');
     return;
   }
-  queuedEvent = hookEventName;
-  parts.push(body);
+  queuedInput = input;
 }
 
 /**
@@ -93,24 +141,25 @@ export function queueHookSystemMessage(text) {
  * @returns {boolean} true when an envelope was written.
  */
 export function flushHookStdout(deps = {}) {
-  const hasContext = queuedEvent && parts.length > 0;
+  const hasContext = Boolean(queuedEvent) && parts.length > 0;
+  const hasInput = Boolean(queuedEvent) && queuedInput !== null;
   const hasSystem = systemParts.length > 0;
-  if (!hasContext && !hasSystem) return false;
+  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');
-  // Omitted entirely when there is no model-facing context: 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) {
-    envelope.hookSpecificOutput = {
-      hookEventName: queuedEvent,
-      additionalContext: parts.join('\n\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');
   }
   parts = [];
   queuedEvent = null;
   systemParts = [];
+  queuedInput = null;
   write(JSON.stringify(envelope) + '\n');
   return true;
 }
@@ -120,9 +169,15 @@ export function resetHookStdout() {
   parts = [];
   queuedEvent = null;
   systemParts = [];
+  queuedInput = null;
 }
 
 /** Test seam: what is queued right now. */
 export function peekHookStdout() {
-  return { hookEventName: queuedEvent, parts: [...parts], systemParts: [...systemParts] };
+  return {
+    hookEventName: queuedEvent,
+    parts: [...parts],
+    systemParts: [...systemParts],
+    updatedInput: queuedInput,
+  };
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.79.0",
+  "version": "3.80.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.79.0",
+      "version": "3.80.0",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.26.0",
         "better-sqlite3": "^12.6.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.79.0",
+  "version": "3.80.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).",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/scripts/post-tool-recall.js

@@ -17,6 +17,11 @@ import { existsSync, readFileSync } from 'fs';
 import { basename, join } from 'path';
 import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
+// D#154: every envelope on this stdout goes through the one writer. This script has a
+// single emit today, so the change buys nothing on its own — it buys that a SECOND
+// emit added later merges instead of producing two JSON documents, which the host
+// parses as neither (lib/hook-stdout.mjs). Import-free module over no runtime deps.
+import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
 
 const SALIENCE_BIND = process.env.CLAUDE_MEM_SALIENCE === 'bind';
 
@@ -69,10 +74,8 @@ async function main() {
   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.`);
   }
-  process.stdout.write(JSON.stringify({
-    suppressOutput: true,
-    hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: lines.join('\n') },
-  }));
+  queueHookContext('PostToolUse', lines.join('\n'));
+  flushHookStdout();
 }
 
 // No forced process.exit(0): main() consumes stdin to EOF (or early-returns without

package/scripts/pre-agent-inject.js

@@ -66,15 +66,28 @@ async function main() {
   const { ensureDb } = await import('../schema.mjs');
   const { inferProject } = await import('../utils.mjs');
   const { buildSubagentInjection } = await import('../hook-memory.mjs');
+  // D#154: single envelope writer. Deferred to this line, not hoisted to a static
+  // import, because the file's stated contract is that the default-off path costs one
+  // env check and nothing else — the deferral filed this as "shared module vs
+  // import-free fast path, pick one", but the script already resolves that conflict
+  // three lines up: dynamic import on the enabled path only. The fast path above is
+  // untouched.
+  const { queueHookUpdatedInput, flushHookStdout } = await import('../lib/hook-stdout.mjs');
 
   let db;
   try { db = ensureDb(); } catch (e) { await recordFailure('agent-inject:db-open', e); return; }
   try {
     const updatedInput = buildSubagentInjection(db, hook.tool_input, inferProject());
     if (updatedInput) {
-      process.stdout.write(JSON.stringify({
-        hookSpecificOutput: { hookEventName: 'PreToolUse', updatedInput },
-      }));
+      // Behaviour delta vs the hand-written envelope this replaced: it now carries
+      // top-level `suppressOutput: true`. Verified display-only in the 2.1.241 bundle —
+      // the field is documented "Hide stdout from transcript (default: false)" and is
+      // read at exactly one place, the transcript-render branch
+      // (`if (a6(he) && !he.suppressOutput && …)`); the updatedInput mutation is taken
+      // from the parsed hookSpecificOutput regardless. Hiding it is also the right
+      // audience call: this payload is the whole prompt echoed back, not a message.
+      queueHookUpdatedInput('PreToolUse', updatedInput);
+      flushHookStdout();
     }
   } catch (e) { await recordFailure('agent-inject:query', e); /* never break a dispatch */ } finally {
     try { db.close(); } catch { /* */ }

package/scripts/pre-skill-bridge.js

@@ -11,6 +11,9 @@ import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
 // format-utils.mjs is import-free — pulling three defang helpers keeps this script
 // inside its "lightweight standalone" budget (no heavy transitive deps).
 import { neutralizeContextDelimiters, neutralizeSkillDelimiters, neutralizeSkillBridgeDelimiters } from '../format-utils.mjs';
+// D#154: single envelope writer. Also import-free (no runtime deps), so it stays
+// inside this script's "lightweight standalone" budget.
+import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
 
 // CLAUDE_MEM_DIR mirrors pre-tool-recall.js — one env var sandboxes everything.
 const DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
@@ -110,13 +113,8 @@ try {
     } else {
       additionalContext = `<skill-bridge name="${safeName}" source="managed">\n${defang(content)}\n</skill-bridge>\n\nThis skill was loaded from the managed registry. Follow the instructions above.`;
     }
-    process.stdout.write(JSON.stringify({
-      suppressOutput: true,
-      hookSpecificOutput: {
-        hookEventName: 'PreToolUse',
-        additionalContext,
-      },
-    }));
+    queueHookContext('PreToolUse', additionalContext);
+    flushHookStdout();
   } catch (e) {
     // Silent failure — never block Skill tool, but record for self-observation.
     recordHookError('skill-bridge:query', e, RUNTIME_DIR, { skillName });

package/scripts/pre-tool-recall.js

@@ -19,6 +19,25 @@ 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';
+// 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.
+//
+// Be precise about what routing them through the queue does and does not buy, because an
+// earlier version of this comment claimed "a second write is now impossible by
+// construction" and that is FALSE (pre-tag review, v3.80.0): each site flushes
+// IMMEDIATELY after queueing, and the flush resets the queue — so queue→flush→queue→flush
+// emits two documents exactly like two raw writes would. Merging is a property of
+// DEFERRING the flush (what hook.mjs does with a single flush at the end of its dispatch),
+// not of using the queue.
+//
+// What it does buy: one construction site instead of three, so the "only the writer
+// assembles an envelope" invariant is checkable (tests/hook-script-stdout-contract.test.mjs),
+// and the merge is AVAILABLE to anyone who later defers the flush. The mutual exclusion
+// itself is still control flow — the process.exit(0) below.
+//
+// Import-free module, no runtime deps — nothing added to this script's load cost.
+import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
 // Recall queries the SAVE-path project, so this MUST produce the same string as the
 // save path. It used to be a hand-kept copy of the same 6 lines; that copy had already
 // drifted once (missing the process.env.PWD fallback, so a symlinked project dir
@@ -305,16 +324,11 @@ try {
       const wasReadMode = typeof entry === 'object' && entry.mode === 'read';
       if (!isRead && wasReadMode && seenIds.length > 0 && !SALIENCE_LEGACY) {
         const idList = seenIds.map(id => `#${id}`).join(', ');
-        process.stdout.write(JSON.stringify({
-          suppressOutput: true,
-          hookSpecificOutput: {
-            hookEventName: 'PreToolUse',
-            additionalContext: [
-              '[mem] PreToolUse recall — system-injected context, continue your planned action:',
-              `[mem] ⚠ Lessons ${idList} were shown when you Read ${basename(filePath)} — ${ACTIVE_DIRECTIVE}`,
-            ].join('\n'),
-          },
-        }));
+        queueHookContext('PreToolUse', [
+          '[mem] PreToolUse recall — system-injected context, continue your planned action:',
+          `[mem] ⚠ Lessons ${idList} were shown when you Read ${basename(filePath)} — ${ACTIVE_DIRECTIVE}`,
+        ].join('\n'));
+        flushHookStdout();
         cooldown[filePath] = { ...entry, mode: 'edit' };
         writeCooldown(cooldownPath, cooldown, isSessionScoped);
       } else if (isRead && !REREAD_GUARD_OFF && typeof entry === 'object' && entry.reread) {
@@ -322,16 +336,11 @@ try {
         // nudge to reuse what's already in context. Read-only; never throws.
         const meta = readFileMeta(filePath);
         if (shouldWarnReread(entry.reread, meta ? meta.mtimeMs : null, isFullRead, REREAD_MIN_TOKENS)) {
-          process.stdout.write(JSON.stringify({
-            suppressOutput: true,
-            hookSpecificOutput: {
-              hookEventName: 'PreToolUse',
-              additionalContext: [
-                '[mem] PreToolUse recall — system-injected context, continue your planned action:',
-                buildRereadWarning(basename(filePath), entry.reread.tokens),
-              ].join('\n'),
-            },
-          }));
+          queueHookContext('PreToolUse', [
+            '[mem] PreToolUse recall — system-injected context, continue your planned action:',
+            buildRereadWarning(basename(filePath), entry.reread.tokens),
+          ].join('\n'));
+          flushHookStdout();
           recordMetric(DATA_DIR, { event: 'reread_warn' }); // tier-1 firing counter (②)
         }
       }
@@ -605,13 +614,8 @@ try {
     }
 
     if (lines.length > 0) {
-      process.stdout.write(JSON.stringify({
-        suppressOutput: true,
-        hookSpecificOutput: {
-          hookEventName: 'PreToolUse',
-          additionalContext: lines.join('\n'),
-        },
-      }));
+      queueHookContext('PreToolUse', lines.join('\n'));
+      flushHookStdout();
     }
     // Cooldown applies on ALL branches (including silent-Read) so subsequent
     // calls on the same file in the same session don't re-query — preserving