claude-mem-lite 6.4.0 → 6.6.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.4.0",
+      "version": "6.6.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)."

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.4.0",
+  "version": "6.6.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/README.md

@@ -896,7 +896,8 @@ benchmark and A/B harness are calibrated against — changing them invalidates t
 | `MEM_DISABLE_CITATION_DECAY` | `1` disables only the decay writes, keeping access-count bumps. | _(enabled)_ |
 | `CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD` | **Removed — inert.** Tuned the per-project adoption gate, which is gone (D#204). Setting it warns on stderr and changes nothing. | _(n/a)_ |
 | `CLAUDE_MEM_NO_CITE_NUDGE` | `1` fully silences the cite-back nudge. | _(enabled)_ |
-| `CLAUDE_MEM_CITE_NUDGE_THRESHOLD` | Cite-rate below which the nudge fires. | `0.6` |
+| `CLAUDE_MEM_CITE_NUDGE_THRESHOLD` | Cite-rate below which the nudge fires. | `0.4` |
+| `CLAUDE_MEM_CITE_NUDGE_WIDE_DENOMINATOR` | `1` judges the wide cite-recall ratio (every `#NN`-shaped token the model saw) instead of the lessons the hooks injected. **Half of the revert**: the threshold moved too, so pre-v6.6.0 gating needs this **and** `CLAUDE_MEM_CITE_NUDGE_THRESHOLD=0.6`. This switch alone gives you the wide ratio judged at 0.4, which is neither release's behaviour. | unset |
 | `CLAUDE_MEM_CITE_NUDGE_MIN_INJECTED` | Minimum injection volume before the ratio gate is judged at all. | `5` |
 | `CLAUDE_MEM_CITE_NUDGE_SILENCE_AFTER` | Consecutive low-cite sessions before the nudge goes quiet; `0` = never silence. | `3` |
 | `CLAUDE_MEM_CITATION_RELEVANCE_GATE` | Stop credits an `access_count` to a memory the session cited only when something made that memory relevant to the session — it was injected, or you typed its `#NN` yourself. `off` restores the pre-v3.84.0 behaviour of crediting every `#NN` the assistant wrote, which over-counts sessions that discuss memories in prose (release notes, audit reports): measured on real transcripts, 267 of 859 credited (id, session) pairs — 31.1% — were mentions nothing had put in front of the model. Superseded citations are redirected to their keeper on both settings. | _(on)_ |

package/hook-context.mjs

@@ -336,6 +336,69 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
  * removes the paired hint comment if present, and normalizes residual whitespace
  * at the seam. Uses atomic tmp+rename write.
  */
+/**
+ * Half-open [start, end) ranges of every fenced code span in a markdown document.
+ *
+ * A fence opens on a line whose first non-space run is three or more backticks or tildes,
+ * and closes on the next line opening with at least as many of the SAME character — CommonMark's
+ * rule, and the reason a ```` ```` ```` block can contain a ``` line. An unterminated fence
+ * runs to EOF.
+ */
+function fencedRanges(content) {
+  const ranges = [];
+  let open = null;
+  let offset = 0;
+  for (const line of content.split('\n')) {
+    const m = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+    if (m) {
+      if (!open) {
+        open = { char: m[1][0], len: m[1].length, start: offset };
+      } else if (m[1][0] === open.char && m[1].length >= open.len) {
+        ranges.push([open.start, offset + line.length]);
+        open = null;
+      }
+    }
+    offset += line.length + 1; // +1 for the '\n' split removed
+  }
+  if (open) ranges.push([open.start, content.length]);
+  return ranges;
+}
+
+/** True when `idx` sits inside a backtick-delimited inline code span on its own line. */
+function insideInlineCode(content, idx) {
+  const lineStart = content.lastIndexOf('\n', idx - 1) + 1;
+  // Count backtick RUNS before the position; an odd count means the position is inside a
+  // span. Runs, not characters: ``code with ` inside`` is one span opened by two ticks.
+  const before = content.slice(lineStart, idx);
+  const runs = before.match(/`+/g);
+  return runs !== null && runs.length % 2 === 1;
+}
+
+/**
+ * The last index of `needle` that is a real block's tag, or -1.
+ *
+ * Three exclusions, and the pre-ship review is why there are three rather than one. A
+ * legacy block written by the old `updateClaudeMd` put its tags at COLUMN 0 on their own
+ * lines, so anything else is prose ABOUT the tag:
+ *   - inside a fenced code span (```/~~~)          — the first cut, and only a third of it
+ *   - not at the start of a line                    — an inline mention mid-sentence
+ *   - indented four or more spaces                  — CommonMark's other code block
+ * Measured before the widening, with the shipped function: an inline span went 101 -> 55
+ * bytes and an indented block 95 -> 33, atomically, with no backup.
+ */
+function lastIndexOutsideFences(content, needle, ranges) {
+  let idx = content.lastIndexOf(needle);
+  while (idx !== -1) {
+    const lineStart = content.lastIndexOf('\n', idx - 1) + 1;
+    const indent = content.slice(lineStart, idx);
+    const atLineStart = indent.length === 0;
+    const inFence = ranges.some(([a, b]) => idx >= a && idx < b);
+    if (atLineStart && !inFence && !insideInlineCode(content, idx)) return idx;
+    idx = content.lastIndexOf(needle, idx - 1);
+  }
+  return -1;
+}
+
 export function cleanupClaudeMdLegacyBlock() {
   // v2.48 P2-4: idempotent marker. First run (whether it finds a block or not,
   // whether CLAUDE.md exists or not) drops a project-scoped marker in RUNTIME_DIR.
@@ -369,10 +432,21 @@ export function cleanupClaudeMdLegacyBlock() {
   const startTag = '<claude-mem-context>';
   const endTag = '</claude-mem-context>';
 
-  // Use lastIndexOf so documentation references to the tag earlier in the file
-  // (e.g. inside a code block in architecture notes) are not accidentally swept.
-  const startIdx = content.lastIndexOf(startTag);
-  const endIdx = content.lastIndexOf(endTag);
+  // A4 (audit 2026-09-08): `lastIndexOf` alone was NOT the protection the old comment
+  // here claimed. It shields a documentation reference only when a real block sits AFTER
+  // it; when the file's only occurrence IS the reference — the ordinary case for someone
+  // who wrote down what this plugin emits — both searches land on it, `startIdx < endIdx`
+  // holds, and the user's fenced sample is deleted with its two fences spliced into a
+  // broken ``````. Atomic write, no backup, once per project, so it shows up as a small
+  // stray diff days later. Measured on a plain 226-byte CLAUDE.md: 226 → 145.
+  //
+  // "The tag is alone on its line" does not discriminate — inside a fence it usually is.
+  // The fence itself is the signal, so fenced spans are excluded before the search, and an
+  // UNTERMINATED fence is treated as running to EOF: that errs toward leaving the file
+  // alone, which is the safe direction for a write into someone's own notes.
+  const fenced = fencedRanges(content);
+  const startIdx = lastIndexOutsideFences(content, startTag, fenced);
+  const endIdx = lastIndexOutsideFences(content, endTag, fenced);
   if (startIdx === -1 || endIdx === -1 || startIdx >= endIdx) {
     dropMarker();
     return;
@@ -585,7 +659,12 @@ export function buildSessionContextLines(
   } else if (!latestSummary && !effectiveQuiet()) {
     // Fallback: no summary AND no key observations — show recent activity.
     // Skipped under QUIET_HOOKS since the Recent table already carries titles.
-    const recentObs = (observations.length >= 3 ? observations : fallbackObs).slice(0, 3);
+    // Slice FIRST, then sort: the slice is the selection (top 3 by value density) and must
+    // stay that way; only the order they are printed in is corrected, same as the Recent
+    // table below. Sorting before the slice would silently change WHICH three are injected.
+    const recentObs = (observations.length >= 3 ? observations : fallbackObs)
+      .slice(0, 3)
+      .sort((a, b) => Date.parse(b.created_at) - Date.parse(a.created_at) || b.id - a.id);
     if (recentObs.length > 0) {
       summaryLines.push('### Recent Activity');
       for (const o of recentObs) {
@@ -695,8 +774,18 @@ export function buildSessionContextLines(
   }
 
   // 6. Recent observations table
+  //
+  // SELECTION order (greedy knapsack, value density) is not DISPLAY order. This block used
+  // to render the picks in the order the knapsack happened to take them, under a heading
+  // that says "Recent" next to a Time column — so row 1 was not the newest row, and both a
+  // human and the model read it as if it were. Sorting here is display-only: `obsToShow` is
+  // already chosen, so the token budget and the row set are untouched (pinned by a case in
+  // tests/hook-context.test.mjs). Tiebroken on id for the same reason D#9 gives — an
+  // untiebroken tie flips direction, and two saves in one millisecond are common.
   const obsLines = [];
-  const obsToShow = observations.length >= 3 ? observations : fallbackObs;
+  const obsToShow = [...(observations.length >= 3 ? observations : fallbackObs)].sort(
+    (a, b) => Date.parse(b.created_at) - Date.parse(a.created_at) || b.id - a.id,
+  );
   if (obsToShow.length > 0) {
     const today = now.toISOString().slice(0, 10);
     obsLines.push(`### Recent (${today})`);

package/hook-llm.mjs

@@ -279,7 +279,7 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
         `
       SELECT title FROM observations
       WHERE project = ? AND created_at_epoch > ?
-      ORDER BY created_at_epoch DESC LIMIT 10
+      ORDER BY created_at_epoch DESC, id DESC LIMIT 10
     `,
       )
       .all(project, fiveMinAgo);
@@ -313,7 +313,7 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
           `
         SELECT title FROM observations
         WHERE project = ? AND created_at_epoch > ? AND created_at_epoch <= ?
-        ORDER BY created_at_epoch DESC LIMIT 60
+        ORDER BY created_at_epoch DESC, id DESC LIMIT 60
       `,
         )
         .all(project, threeDaysAgo, fiveMinAgo);
@@ -331,7 +331,7 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
           `
         SELECT minhash_sig FROM observations
         WHERE project = ? AND created_at_epoch > ? AND minhash_sig IS NOT NULL
-        ORDER BY created_at_epoch DESC LIMIT 200
+        ORDER BY created_at_epoch DESC, id DESC LIMIT 200
       `,
         )
         .all(project, sevenDaysAgo);
@@ -1383,7 +1383,7 @@ export async function handleLLMSummary() {
       FROM observations
       WHERE memory_session_id = ?
         AND ${notLowSignalTitleClause('')}
-      ORDER BY created_at_epoch DESC
+      ORDER BY created_at_epoch DESC, id DESC
       LIMIT 30
     `,
       )
@@ -1585,28 +1585,33 @@ ${obsList}`;
 // spinning up the full LLM dispatcher. Lets the e2e leak test verify that
 // the observations INSERT path scrubs all configured text fields.
 export const __insertObservationForTest = (db, obs) => {
+  // R11 C-P3-3: this used to hand-spell an 18-column INSERT of its own while the
+  // shipping writer above went through insertObservationRow's 19-column list, so the
+  // secret-scrub leak test asserted on a REPLICA of the write point rather than the
+  // write point. Column-list drift between the two is exactly what
+  // lib/observation-write.mjs exists to make impossible, and a test copy is the one
+  // caller that can drift without anyone noticing — it has no user.
   const safe = scrubRecord('observations', obs);
-  db.prepare(
-    `INSERT INTO observations (memory_session_id, project, text, type, title, subtitle, narrative, concepts, facts, files_read, files_modified, importance, minhash_sig, lesson_learned, search_aliases, branch, created_at, created_at_epoch)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-  ).run(
-    obs.session_id,
-    obs.project,
-    safe.text,
-    'change',
-    safe.title,
-    safe.subtitle,
-    safe.narrative,
-    safe.concepts,
-    safe.facts,
-    obs.files_read,
-    obs.files_modified,
-    obs.importance,
-    obs.minhash_sig,
-    safe.lesson_learned,
-    safe.search_aliases,
-    obs.branch,
-    new Date().toISOString(),
-    Date.now(),
-  );
+  const now = new Date();
+  return insertObservationRow(db, {
+    memory_session_id: obs.session_id,
+    project: obs.project,
+    text: safe.text,
+    type: 'change',
+    title: safe.title,
+    subtitle: safe.subtitle,
+    narrative: safe.narrative,
+    concepts: safe.concepts,
+    facts: safe.facts,
+    files_read: obs.files_read,
+    files_modified: obs.files_modified,
+    importance: obs.importance,
+    minhash_sig: obs.minhash_sig,
+    lesson_learned: safe.lesson_learned,
+    search_aliases: safe.search_aliases,
+    branch: obs.branch,
+    created_at: now.toISOString(),
+    created_at_epoch: now.getTime(),
+    scope: normalizeScope(obs.scope),
+  });
 };

package/hook-memory.mjs

@@ -8,12 +8,9 @@ import {
   OBS_BM25,
   notLowSignalTitleClause,
   noisePenaltyClause,
-  tokenizeHandoff,
-  HANDOFF_STOP_WORDS,
-  extractCjkKeywords,
   neutralizeContextDelimiters,
 } from './utils.mjs';
-import { upsFtsQuery } from './lib/ups-query.mjs';
+import { upsFtsQuery, upsQueryTerms } from './lib/ups-query.mjs';
 import { citeFactorJs, TYPE_QUALITY, TYPE_QUALITY_DEFAULT } from './scoring-sql.mjs';
 import { liveObsFilterSql } from './lib/inject-search-core.mjs';
 import { recordMetric } from './lib/metrics.mjs';
@@ -169,17 +166,6 @@ function getCrossProjectBoost() {
   const n = parseFloat(raw);
   return Number.isFinite(n) && n >= 0 && n <= 1 ? n : 0.4;
 }
-function extractQueryTerms(text) {
-  if (!text) return [];
-  const ascii = tokenizeHandoff(text).filter((t) => !HANDOFF_STOP_WORDS.has(t));
-  let cjk = [];
-  try {
-    cjk = extractCjkKeywords(text) || [];
-  } catch {
-    /* CJK extraction best-effort */
-  }
-  return [...new Set([...ascii, ...cjk.map((t) => String(t).toLowerCase())])];
-}
 // v2.41: hay spans every FTS column whose BM25 weight is >=5 in OBS_BM25
 // (title=10, subtitle=5, narrative=5, lesson_learned=8). Pre-v2.41 was only
 // title + lesson_learned — rows that matched on narrative but happened to
@@ -509,7 +495,16 @@ export function searchRelevantMemories(
     let coverageFiltered = aboveThreshold;
     const coverageThreshold = getCoverageThreshold();
     if (coverageThreshold > 0) {
-      const queryTerms = extractQueryTerms(userPrompt);
+      // A1: the denominator is the terms the query was actually BUILT from, via the one
+      // source (lib/ups-query.mjs -> nlp.mjs::ftsQueryTokens). Counting anything else
+      // counts terms that were never searched, so no matched row can cover them and the
+      // ratio falls with prompt length until the whole surface goes silent.
+      //
+      // The first cut of this fix shared only maxChars and the pre-ship review measured
+      // the hole it left: sanitizeFtsQuery also caps at maxTokens = 64, so a 1511-character
+      // prompt — under the char cap, where the shared cut is a no-op — still returned []
+      // against a row whose narrative was the entire prompt.
+      const queryTerms = upsQueryTerms(userPrompt);
       if (queryTerms.length >= COVERAGE_MIN_QUERY_TERMS) {
         coverageFiltered = aboveThreshold.filter(
           (r) => candidateCoverage(r, queryTerms) >= coverageThreshold,

package/hook-optimize.mjs

@@ -1517,6 +1517,13 @@ export async function executeSmartCompressCluster(db, observations, project) {
       //
       // optimized_at is not in OBS_COLUMNS, so it stays a separate UPDATE below — the
       // summary must be marked processed so the re-enrich pools do not pick it up.
+      //
+      // R11 C-P3-2 read the three-item list above as a completeness claim and asked why
+      // the fourth OBS_COLUMNS entry, `scope`, is absent. It is absent on purpose: the
+      // merge prompt does not ask for one, so there is no value to pass, and NULL is the
+      // `scopes` backfill pool's own predicate (findReenrichCandidates, scope==='scopes')
+      // — which is deliberately NOT gated on optimized_at, so stamping this row processed
+      // does not evict it. Writing a guessed scope here would.
       const newId = insertObservationRow(db, {
         memory_session_id: sessionId,
         project,

package/hook-shared.mjs

@@ -28,6 +28,8 @@ import {
   shouldRecordSkew,
   SKEW_MARKER_PREFIX,
 } from './lib/schema-skew.mjs';
+import { isDbUnusableError, DB_UNUSABLE_MARKER_PREFIX } from './lib/db-unusable.mjs';
+import { shouldRecordOnce } from './lib/record-once.mjs';
 // Audit 2026-09-05 P1-2 (carried from 2026-09-02 P2-9): `callLLM`, the quiet/adoption
 // predicates and the handoff constants moved into `lib/` because two lib modules
 // imported them from here and dragged this file's whole import graph — haiku-client,
@@ -244,6 +246,9 @@ export const GC_PROJECT_MARKER_PREFIXES = Object.freeze([
   // v5.0.0; a prefix for files nothing writes any more is dead weight in a hot-path loop.
   'last-mark-compressible-', // per-project auto-compress 24h gate
   SKEW_MARKER_PREFIX, // per-project schema-skew log dedup; regenerated on the next skewed open
+  // Same shape, same reason, and it was missed here first time round — the note above is
+  // about exactly this defect, two entries up.
+  DB_UNUSABLE_MARKER_PREFIX, // per-project unopenable-DB log dedup; regenerated on the next failing open
 ]);
 
 // Records of a completed side effect — never age out. `ep-`/`ep-flush-`/
@@ -405,12 +410,28 @@ export function lastSchemaSkew() {
   return lastSkew;
 }
 
+// Same idea, other unhealable family: the file exists and SQLite will not open it. Held as a
+// boolean rather than the error, because the only thing SessionStart needs is "which notice",
+// and keeping an Error alive here would tempt a caller into rendering a stack trace at a user.
+let lastUnusable = false;
+
+/**
+ * True when the most recent openDb() returned null because the database file is not a usable
+ * database. Cleared by any successful open, so a repair mid-session stops the notice.
+ *
+ * @returns {boolean}
+ */
+export function lastDbUnusable() {
+  return lastUnusable;
+}
+
 export function openDb() {
   try {
     // WAL-corruption self-heal (was server.mjs-only): without it, hooks stayed
     // silently dead (null DB) on a corrupt WAL until the next MCP server start.
     const db = ensureDbWithWalRecovery();
     lastSkew = null;
+    lastUnusable = false;
     return db;
   } catch (e) {
     // Forward-incompat is its own family: it cannot be healed by anything this process can
@@ -423,10 +444,11 @@ export function openDb() {
     //
     // shouldRecordSkew is TOTAL by contract. Nothing in this catch may throw: the first cut
     // called getSessionId() here, which MINTS and writes a session id, so an unwritable
-    // runtime dir turned openDb() itself into a thrower. All 13 call sites are written to
+    // runtime dir turned openDb() itself into a thrower. All 12 openDb() call sites in hook.mjs are written to
     // no-op on null and none of them expects an exception.
     if (isSchemaSkewError(e)) {
       lastSkew = schemaSkewFromError(e) || { dbVersion: null, binaryVersion: null };
+      lastUnusable = false;
       // Guarded even though inferProject() reads env and cwd: "the only statement in this
       // catch cannot throw" was true of the original one-line body and stopped being true
       // the moment anything was added. An unscoped marker is a worse dedup, not a crash.
@@ -441,8 +463,31 @@ export function openDb() {
       }
       return null;
     }
-    // Still null, still no throw — a hook must never crash the host session, and all
-    // eight call sites in hook.mjs are written to no-op on null. But "returned null"
+    // The OTHER unhealable family, and it was the silent one. A file that is not a database
+    // repeats on every fire exactly like a skew does, and until now took the generic branch
+    // below: one full stack trace per SessionStart fire (measured: 20 fires → 20 records, ~860 B
+    // each), no dedup, and no user-visible word anywhere in the session. Same treatment as skew
+    // — record once per project per hour, and hand SessionStart a flag to speak with.
+    //
+    // Nothing in this branch may throw: `isDbUnusableError` is a regex over a string and
+    // `shouldRecordOnce` is total by contract, which is exactly the property the first cut of
+    // the skew dedup lost by calling a function that WRITES.
+    if (isDbUnusableError(e)) {
+      lastUnusable = true;
+      lastSkew = null; // the two flags are a set: whichever family fired last is the true one
+      let project = '';
+      try {
+        project = inferProject();
+      } catch {
+        /* total: the marker degrades to one shared file */
+      }
+      if (shouldRecordOnce(RUNTIME_DIR, DB_UNUSABLE_MARKER_PREFIX, project, 'unusable')) {
+        recordHookError('hook-shared:db-open', e, RUNTIME_DIR);
+      }
+      return null;
+    }
+    // Still null, still no throw — a hook must never crash the host session, and all 12
+    // openDb() call sites in hook.mjs are written to no-op on null. But "returned null"
     // used to be the ONLY trace: nothing reached runtime/hook-errors/, so `stats`
     // reported 0 and doctor printed "no recent silent hook breakage" while every
     // capture path was dead (audit B1, 2026-08-14 — the same blindness that hid the

package/hook.mjs

@@ -62,7 +62,7 @@ import {
 } from './hook-episode.mjs';
 // CODE_DIR, not DB_DIR: the schema-skew notice asks which CODE homes exist, and those are
 // always homedir-rooted even when CLAUDE_MEM_DIR relocates the data.
-import { DB_DIR, CODE_DIR } from './schema.mjs';
+import { DB_DIR, DB_PATH, CODE_DIR } from './schema.mjs';
 import { cleanupClaudeMdLegacyBlock, buildSessionContextLines } from './hook-context.mjs';
 import { entry as preCompactEntry } from './hook-precompact.mjs';
 import {
@@ -85,6 +85,7 @@ import {
   sweepOrphanEpisodeFiles,
   sweepStaleProjectMarkers,
   lastSchemaSkew,
+  lastDbUnusable,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveEpisodeImmediate } from './hook-llm.mjs';
 import { readFastSummarySource, insertFastSummary, FAST_SUMMARY_LIMITS } from './lib/fast-summary.mjs';
@@ -1405,6 +1406,34 @@ function trackCitationsAtStop(db, { sessionId, project, ccSessionId, transcriptP
       // which was ~all of the cost.)
       try {
         const stats = computeCiteRecall(transcriptPath);
+        // D#19: the RATIO GATE's own denominator, alongside the wide one. `stats` counts
+        // every `#NN`-shaped token in non-assistant text — tool_result bodies, file
+        // contents, CLI output, pasted reports — which is the right caliber for "what has
+        // the model seen" and the wrong one for "did it cite back what the hooks gave it"
+        // (measured 11.2x inflation, R11-B-P2-2). Both are persisted; buildCiteRecallNudge
+        // gates on this pair and falls back to the wide one for older payloads.
+        //
+        // Cost is an array iteration, not a parse: this block runs after the decay loop's
+        // own extractInjectedBySurface on the same path, and lib/transcript-scan.mjs memoizes
+        // the parse. mainOnly mirrors the decay loop — an id injected only inside a subagent
+        // would otherwise enter the denominator while its citation lands in another
+        // transcript, scoring a miss the main thread never had a chance to avoid.
+        let gate = { gateInjected: null, gateRecalled: null, gateRatio: null };
+        try {
+          const gateInjectedIds = unionSurfaces(extractInjectedBySurface(transcriptPath, { mainOnly: true }));
+          const gateCited = extractCitationsFromTranscript(transcriptPath, { mainOnly: true });
+          let hit = 0;
+          for (const id of gateInjectedIds) if (gateCited.has(id)) hit++;
+          gate = {
+            gateInjected: gateInjectedIds.size,
+            gateRecalled: hit,
+            gateRatio: gateInjectedIds.size > 0 ? hit / gateInjectedIds.size : 0,
+          };
+        } catch (e) {
+          // Leaving the gate* keys null is the defined fallback, not a silent loss: the
+          // reader treats a payload without them exactly like a pre-release one.
+          debugCatch(e, 'handleStop-cite-recall-gate-denominator');
+        }
         // B2 (v2.83.1): also persist the bugfix-shape nudge/save delta so
         // the next SessionStart can surface "N unsaved bugfix-shape edits"
         // alongside cite-recall. Same scan target (transcript already in OS
@@ -1421,11 +1450,13 @@ function trackCitationsAtStop(db, { sessionId, project, ccSessionId, transcriptP
         // always said. Stop fires once per assistant TURN, so incrementing here silenced
         // the nudge inside the first session — this machine read lowStreak 58 against 26
         // transcripts before the fix.
-        const { lowStreak, streakBase, lastStreakSession } = nextCiteStreakState(
-          prevPayload,
-          ccSessionId,
-          stats,
-        );
+        // D#19: the streak advances on the SAME gate the nudge fires on, so the merged
+        // stats go in. Handing it the wide triple alone would let the streak climb on a
+        // verdict the SessionStart surface never reached — two policies, one counter.
+        const { lowStreak, streakBase, lastStreakSession } = nextCiteStreakState(prevPayload, ccSessionId, {
+          ...stats,
+          ...gate,
+        });
         // G3: finalized-in-conversation + zero deliberate persistence →
         // decisionSignal rides the payload; next SessionStart reminds once.
         let decisionSignal = null;
@@ -1448,6 +1479,7 @@ function trackCitationsAtStop(db, { sessionId, project, ccSessionId, transcriptP
         }
         const payload = {
           ...stats,
+          ...gate,
           ...bugfixStats,
           lowStreak,
           streakBase,
@@ -1592,8 +1624,9 @@ async function handleStop() {
 
 // Build the SessionStart nudge line shown when the prior session's cite-recall
 // fell below threshold. Empty string = no surface (insufficient signal, recall
-// already healthy, or feature opted-out via env). Default threshold 0.6,
-// min injected 5 — both env-overridable for ops tuning + tests.
+// already healthy, or feature opted-out via env). Default threshold 0.4 against the
+// HOOK-INJECTED denominator (v6.6.0, D#19), min injected 5 — both env-overridable for
+// ops tuning + tests; CLAUDE_MEM_CITE_NUDGE_WIDE_DENOMINATOR=1 restores the wide one.
 // Thin wrapper: lib/cite-back-hint.mjs owns the logic so it stays unit-tested.
 // Passing module-level RUNTIME_DIR keeps the call site identical to pre-v2.83.1.
 function buildCiteRecallNudge(project) {
@@ -2354,6 +2387,33 @@ async function emitSchemaSkewNotice() {
   }
 }
 
+/**
+ * The corruption twin of emitSchemaSkewNotice. Same channels, same reason they are BOTH used:
+ * queueHookContext reaches the model, queueHookSystemMessage reaches the human, and a notice
+ * whose whole job is handing the user a command must not depend on the assistant volunteering
+ * it (lib/hook-stdout.mjs names v3.70.0 for exactly that mistake).
+ *
+ * Dynamically imported like its twin: a cold path must not cost the healthy SessionStart a
+ * directory scan for backup snapshots.
+ */
+async function emitDbUnusableNotice() {
+  try {
+    if (!lastDbUnusable()) return;
+    const mod = await import('./lib/db-unusable.mjs');
+    // TWO DIFFERENT STRINGS, unlike the skew twin, and the asymmetry is the point: the
+    // human channel carries the repair command, the model channel carries only the fact.
+    // See formatDbUnusableModelNotice — this family's remedy overwrites the database.
+    queueHookSystemMessage(
+      mod.formatDbUnusableNotice({ dbPath: DB_PATH, remedy: mod.dbUnusableRemedy(DB_PATH) }),
+    );
+    queueHookContext('SessionStart', mod.formatDbUnusableModelNotice());
+  } catch (e) {
+    // A hook must never crash the host session, and a notice that cannot render is better
+    // handled by staying quiet than by taking SessionStart down with it.
+    debugCatch(e, 'session-start-db-unusable');
+  }
+}
+
 async function handleSessionStart() {
   // GC stale per-session cooldown files. Cheap (<5ms typical) and idempotent;
   // moved here from pre-tool-recall.js's hot path.
@@ -2542,7 +2602,13 @@ async function handleSessionStart() {
     // only other signal it produces is a `-32000 Connection closed` from the MCP host, which
     // names nothing. Measured 2026-09-08: a whole day of it, >=648 log lines, zero words to
     // the user. This is the surface the user actually reads.
+    //
+    // A database file that is not a database is the same shape and got the same treatment:
+    // unhealable without the user, disables every path, and every OTHER surface (CLI exit 1,
+    // `status`, `doctor` with an exact repair command) already reports it — leaving the
+    // in-session one as the only silent one.
     await emitSchemaSkewNotice();
+    await emitDbUnusableNotice();
     return;
   }