claude-mem-lite 3.66.0 → 3.66.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.66.0",
+      "version": "3.66.2",
       "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.66.0",
+  "version": "3.66.2",
   "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/haiku-client.mjs

@@ -428,26 +428,122 @@ async function callModelAPI(prompt, model, { timeout, maxTokens, temperature = D
   }
 }
 
+// ─── Headless CLI flag compatibility ─────────────────────────────────────────
+//
+// --no-session-persistence + DISABLE_CLAUDEMD_HOOKS (2026-08-16): these headless
+// calls were paying the full interactive-session tax — 1,004 transcripts piled up
+// in ~/.claude/projects/-tmp/, and every spawn ran the claudemd plugin's whole
+// hook fan-out (its SessionStart banner alone logged 682 rows in 3 days, drowning
+// that project's telemetry). The persistence flag is OAuth-safe (probed);
+// `--bare`/CLAUDE_CODE_SIMPLE are NOT (they hard-require ANTHROPIC_API_KEY —
+// "Not logged in" on OAuth machines). The user's global CLAUDE.md injection has
+// no OAuth-safe opt-out; accepted (haiku + prompt caching keeps it cheap).
+//
+// The flag is an unguarded dependency on a recent Claude Code CLI: package.json
+// declares only node>=20, no Claude Code floor. On an older binary the spawn dies
+// in argument parsing, the catch swallows it, and every CLI-leg LLM call returns
+// null — no retry, no telemetry. That leg is what the keyed providers degrade to,
+// so such a user loses enrichment, summarization and optimize all at once. So:
+// detect the arg-parse rejection, retry once without the flag, and cache the
+// negative only AFTER the retry actually succeeded. Caching on the failure
+// instead would let one transient non-zero exit that happens to mention the flag
+// push a healthy CLI back onto the session tax for the rest of the process.
+// Hooks are short-lived, so an old binary pays one extra fail-fast spawn per
+// process; the long-lived MCP server pays it once per run.
+const HEADLESS_FLAG = '--no-session-persistence';
+let _headlessFlagOk = true;
+
+/** @internal test hook — module-level compat state must not leak across cases. */
+export function _resetHeadlessFlag() { _headlessFlagOk = true; }
+
+function claudeArgs(modelName) {
+  return _headlessFlagOk
+    ? ['-p', '--model', modelName, HEADLESS_FLAG]
+    : ['-p', '--model', modelName];
+}
+
+// A retry is only ever worth it when the diagnostic NAMES the token it rejected —
+// every argv parser does, and requiring it is what keeps this from firing on
+// Claude Code's own config diagnostics. The installed CLI carries strings like
+// `Skill X has invalid effort 'y'. Valid options: …` and `Input validation error:
+// Invalid arguments for tool`, which an unanchored unknown-word/option-word regex
+// matches outright. Those are emitted for a malformed agent/skill file — a
+// *persistent* condition — so an unanchored match would fire on the next transient
+// 529, permanently revert v3.66.0's session-tax fix on a perfectly healthy CLI,
+// and log a WARN blaming a flag that was never the problem (pre-tag review, HIGH).
+// Deliberately NOT keyed on exit code alone either: a non-zero exit is also the
+// normal shape of an overload/auth failure.
+const FLAG_TOKEN = /no-session-persistence/;
+const PARSE_REJECTION = /(unknown|unrecognized|unsupported|invalid|unexpected)[^\n]{0,40}(option|argument|flag|switch)/i;
+
+// Below this many ms left, a retry can only spawn a process and immediately kill
+// it — worse than returning the original failure.
+const RETRY_MIN_BUDGET_MS = 500;
+
+export function _isUnknownFlagError(diagnostic) {
+  if (!diagnostic) return false;
+  return FLAG_TOKEN.test(diagnostic) && (PARSE_REJECTION.test(diagnostic) || /usage:/i.test(diagnostic));
+}
+
+// stdout as well as stderr: a parser that prints its rejection (or usage banner)
+// on stdout is otherwise invisible here, and FLAG_TOKEN keeps the widened input
+// from loosening the match.
+function cliDiagnostic(e) {
+  const err = e?.stderr?.toString?.() || e?.output?.[2]?.toString?.() || '';
+  const out = e?.stdout?.toString?.() || e?.output?.[1]?.toString?.() || '';
+  return `${err}\n${out}`;
+}
+
+/**
+ * Shared blocking `claude -p` runner for every sync CLI leg (callModelCLI,
+ * callHaikuCLI, hook-shared#callLLM). Throws exactly what execFileSync throws so
+ * each caller keeps its own partial-output salvage; the only added behaviour is
+ * the one-shot flag-compat retry described above.
+ * @param {string} modelName CLI model name ('haiku'|'sonnet')
+ * @param {{input:string, timeout:number}} opts
+ * @returns {string} raw stdout
+ */
+export function execClaudeCliSync(modelName, { input, timeout }) {
+  const opts = {
+    input,
+    timeout,
+    encoding: 'utf8',
+    env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1', DISABLE_CLAUDEMD_HOOKS: '1' },
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: '/tmp', // Prevent ghost sessions in the user's /resume list
+  };
+  const args = claudeArgs(modelName);
+  const started = Date.now();
+  try {
+    return execFileSync(getClaudePath(), args, opts);
+  } catch (e) {
+    // A timeout is NOT a parse rejection. execFileSync kills the child and throws
+    // with its partial buffers attached (callModelCLI's salvage depends on exactly
+    // that), so without this guard a slow call whose output merely looked
+    // parse-shaped would be retried on the FULL original budget — doubling a
+    // latency-bound ceiling. lesson-bridge runs this leg at 2500ms on PreToolUse,
+    // where the CLI is measured at 8–13s and therefore times out routinely.
+    if (e?.killed || e?.signal) throw e;
+    // `args`, not the live flag: what matters is whether THIS attempt carried it.
+    // Symmetry with the async leg, where the distinction is load-bearing (a
+    // sibling can flip the flag across an await). Here execFileSync blocks the
+    // event loop for the whole child, so no other JS can interleave and the two
+    // readings are behaviourally identical — the substitution is deliberately
+    // mutation-silent, kept so the two legs cannot drift apart in meaning.
+    if (!args.includes(HEADLESS_FLAG) || !_isUnknownFlagError(cliDiagnostic(e))) throw e;
+    const remaining = timeout - (Date.now() - started);
+    if (remaining < RETRY_MIN_BUDGET_MS) throw e;
+    const out = execFileSync(getClaudePath(), ['-p', '--model', modelName], { ...opts, timeout: remaining });
+    _headlessFlagOk = false;
+    debugLog('WARN', 'cli-compat', `claude CLI rejected ${HEADLESS_FLAG}; dropped for this process (the headless session tax returns — upgrade Claude Code to avoid it)`);
+    return out;
+  }
+}
+
 function callModelCLI(prompt, model, { timeout }) {
   const modelName = MODEL_MAP[model] ? model : 'haiku';
   try {
-    // --no-session-persistence + DISABLE_CLAUDEMD_HOOKS (2026-08-16): these
-    // headless calls were paying the full interactive-session tax — 1,004
-    // transcripts piled up in ~/.claude/projects/-tmp/, and every spawn ran
-    // the claudemd plugin's whole hook fan-out (its SessionStart banner alone
-    // logged 682 rows in 3 days, drowning that project's telemetry). The
-    // persistence flag is OAuth-safe (probed); `--bare`/CLAUDE_CODE_SIMPLE are
-    // NOT (they hard-require ANTHROPIC_API_KEY — "Not logged in" on OAuth
-    // machines). The user's global CLAUDE.md injection has no OAuth-safe
-    // opt-out; accepted (haiku + prompt caching keeps it cheap).
-    const result = execFileSync(getClaudePath(), ['-p', '--model', modelName, '--no-session-persistence'], {
-      input: flattenForCLI(prompt),
-      timeout,
-      encoding: 'utf8',
-      env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1', DISABLE_CLAUDEMD_HOOKS: '1' },
-      stdio: ['pipe', 'pipe', 'pipe'],
-      cwd: '/tmp',
-    });
+    const result = execClaudeCliSync(modelName, { input: flattenForCLI(prompt), timeout });
     const text = result.trim();
     return text ? { text } : null;
   } catch (e) {
@@ -479,23 +575,31 @@ function callModelCLI(prompt, model, { timeout }) {
  * @param {{timeout:number}} opts  SIGKILL after `timeout` ms; no retry.
  * @returns {Promise<{text:string}|null>}
  */
-export function callModelCLIAsync(prompt, model, { timeout }) {
-  return new Promise((resolve) => {
-    const modelName = MODEL_MAP[model] ? model : 'haiku';
+export async function callModelCLIAsync(prompt, model, { timeout }) {
+  const modelName = MODEL_MAP[model] ? model : 'haiku';
+  const payload = flattenForCLI(prompt);
+  const started = Date.now();
+
+  // One spawn. Resolves {result, stderr, stdout, code}, never rejects. `code` is
+  // a number ONLY when the child exited on its own; a timeout/SIGKILL or a spawn
+  // error reports null, which is what keeps either from being mistaken for an
+  // argument-parse rejection and costing a second full-budget spawn.
+  const attempt = (args, budget) => new Promise((resolve) => {
     let child;
     try {
-      // Same headless-tax flags as callModelCLI (rationale there).
-      child = spawn(getClaudePath(), ['-p', '--model', modelName, '--no-session-persistence'], {
+      // Same headless-tax flags + flag-compat retry as callModelCLI (rationale there).
+      child = spawn(getClaudePath(), args, {
         env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1', DISABLE_CLAUDEMD_HOOKS: '1' },
         cwd: '/tmp',
         stdio: ['pipe', 'pipe', 'pipe'],
       });
     } catch (e) {
       debugCatch(e, `${model}-cli-async`);
-      resolve(null);
+      resolve({ result: null, stderr: '', stdout: '', code: null });
       return;
     }
     let stdout = '';
+    let stderr = '';
     let settled = false;
     const done = (val) => {
       if (settled) return;
@@ -510,26 +614,59 @@ export function callModelCLIAsync(prompt, model, { timeout }) {
       // brace check would discard a complete-but-```json-fenced payload (#8605);
       // parseJsonFromLLM strips fences before validating, and the caller re-parses
       // the returned text the same way.
-      if (t && parseJsonFromLLM(t) !== null) { done({ text: t }); return; }
-      done(null);
-    }, timeout);
+      if (t && parseJsonFromLLM(t) !== null) { done({ result: { text: t }, stderr, stdout, code: null }); return; }
+      done({ result: null, stderr, stdout, code: null });
+    }, budget);
     child.stdout?.setEncoding('utf8'); // decode multi-byte UTF-8 (CJK) across chunk boundaries
     child.stdout?.on('data', (d) => { stdout += d; });
-    child.stderr?.on('data', () => {}); // drain stderr so a chatty child can't block on a full pipe
-    child.on('error', (e) => { debugCatch(e, `${model}-cli-async`); done(null); });
-    child.on('close', () => {
+    // Keep draining stderr so a chatty child can't block on a full pipe, but keep
+    // a bounded head of it — the flag-compat probe needs the parser's complaint.
+    // Slice AFTER appending: checking the length first lets one arbitrarily large
+    // chunk through whole, which is the shape a single big stderr write takes.
+    child.stderr?.setEncoding?.('utf8');
+    child.stderr?.on('data', (d) => { stderr = (stderr + d).slice(0, 4096); });
+    child.on('error', (e) => { debugCatch(e, `${model}-cli-async`); done({ result: null, stderr: '', stdout: '', code: null }); });
+    child.on('close', (code) => {
       const t = stdout.trim();
-      done(t ? { text: t } : null);
+      done({ result: t ? { text: t } : null, stderr, stdout, code });
     });
     // EPIPE guard: the child may exit before we finish writing stdin.
     child.stdin?.on('error', () => {});
     try {
-      child.stdin?.write(flattenForCLI(prompt));
+      child.stdin?.write(payload);
       child.stdin?.end();
     } catch (e) {
       debugCatch(e, `${model}-cli-async:stdin`);
     }
   });
+
+  const firstArgs = claudeArgs(modelName);
+  const first = await attempt(firstArgs, timeout);
+  // Judged on `firstArgs`, not the live flag: a concurrent sibling may have
+  // flipped it between our spawn and our resume, and reading the global there
+  // would silently deny THIS call the retry it earned (MCP server, concurrent
+  // deep-search escalations). Gating on the exit code before `first.result` also
+  // covers a CLI that prints its usage banner to stdout and exits non-zero —
+  // otherwise that banner is returned as the model's answer and nothing retries.
+  const rejected = firstArgs.includes(HEADLESS_FLAG)
+    && typeof first.code === 'number' && first.code !== 0
+    && _isUnknownFlagError(`${first.stderr}\n${first.stdout.slice(0, 4096)}`);
+  if (!rejected) return first.result;
+  // The rejection is instantaneous (the child dies in argv parsing), so the retry
+  // normally gets nearly the whole budget; spend only what is left of it.
+  const remaining = timeout - (Date.now() - started);
+  if (remaining < RETRY_MIN_BUDGET_MS) return first.result;
+  const second = await attempt(['-p', '--model', modelName], remaining);
+  // Cache on the retry's EXIT, not its payload. Empty output is a designed
+  // outcome here (emit-nothing prompts, an `N/A` that trims away), so keying on
+  // text left the long-lived MCP server re-probing — two spawns per call, for the
+  // life of the process — on exactly the old CLI this exists to rescue. The sync
+  // twin caches on any non-throwing run; this now means the same thing.
+  if (second.code === 0) {
+    _headlessFlagOk = false;
+    debugLog('WARN', `${model}-cli-async`, `claude CLI rejected ${HEADLESS_FLAG}; dropped for this process (the headless session tax returns — upgrade Claude Code to avoid it)`);
+  }
+  return second.result;
 }
 
 // ─── API Mode ────────────────────────────────────────────────────────────────
@@ -635,15 +772,8 @@ async function callOpenRouterAPI(prompt, tier, { timeout, maxTokens, temperature
 function callHaikuCLI(prompt, { timeout }) {
   const { cli: modelName } = resolveModel();
   try {
-    // Same headless-tax flags as callModelCLI (rationale there).
-    const result = execFileSync(getClaudePath(), ['-p', '--model', modelName, '--no-session-persistence'], {
-      input: flattenForCLI(prompt),
-      timeout,
-      encoding: 'utf8',
-      env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1', DISABLE_CLAUDEMD_HOOKS: '1' },
-      stdio: ['pipe', 'pipe', 'pipe'],
-      cwd: '/tmp', // Prevent ghost sessions in user's /resume list
-    });
+    // Same headless-tax flags + flag-compat retry as callModelCLI (rationale there).
+    const result = execClaudeCliSync(modelName, { input: flattenForCLI(prompt), timeout });
     const text = result.trim();
     return text ? { text } : null;
   } catch (e) {

package/hook-shared.mjs

@@ -1,7 +1,7 @@
 // claude-mem-lite: Shared infrastructure for hook.mjs and hook-llm.mjs
 // Constants, session management, DB access, LLM calls, process utilities
 
-import { execFileSync, spawn } from 'child_process';
+import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { join } from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, readdirSync, statSync, unlinkSync, chmodSync } from 'fs';
@@ -10,7 +10,7 @@ import { ensureDbWithWalRecovery, DB_DIR } from './schema.mjs';
 // Pure-`node:`/local module (it imports only binding-probe + native-binding-hint, and
 // neither imports this file) — no cycle.
 import { recordHookError } from './lib/hook-telemetry.mjs';
-import { getClaudePath as getClaudePathShared, resolveModel as resolveModelShared, flattenForCLI as _flattenForCLI, detectMode as detectLLMMode, callHaiku, BG_LLM_TIMEOUT_MS } from './haiku-client.mjs';
+import { execClaudeCliSync, resolveModel as resolveModelShared, flattenForCLI as _flattenForCLI, detectMode as detectLLMMode, callHaiku, BG_LLM_TIMEOUT_MS } from './haiku-client.mjs';
 // Phase D: invited-memory sentinel detection. memdir.mjs/claudemd.mjs only pull in
 // fs/path/os/crypto; adopt-content.mjs is pure strings. No circular deps —
 // neither imports hook-shared.
@@ -148,12 +148,6 @@ export const GC_PROJECT_MARKER_PREFIXES = Object.freeze([
   'cite-recall-',             // last session's cite-recall snapshot (nudge input)
   '.skill-cooldown-',         // suggestion throttle timestamp
   '.skill-reco-cooldown-',    // recommendation throttle timestamp
-  // These two have NO writer and NO reader left in the tree (verified by grep,
-  // 2026-08-16) — they are version-keyed one-time markers from retired code
-  // paths (live dir holds `.mcp-dedup-v2.10`, `.residue-warned-v2.55`). Nothing
-  // recreates them, so sweeping them is a one-shot cleanup, not a policy.
-  '.mcp-dedup-',
-  '.residue-warned-',
 ]);
 
 // Records of a completed side effect — never age out. `ep-`/`ep-flush-`/
@@ -164,8 +158,45 @@ export const GC_PRESERVED_MARKER_PREFIXES = Object.freeze([
   '.auto-adopt-',
   '.deferred-block-migrated-',
   '.legacy-claude-md-cleaned-',
+  // v3.66.1: these two shipped in the GC list for one release and had to come
+  // out. Both are version-keyed one-shot migration sentinels written by
+  // scripts/setup.sh, and their gate is `! -f <marker>` — deleting one re-runs
+  // its migration. `.mcp-dedup-v2.78` gates a block that removes
+  // mcpServers.mem / mcpServers["mem-lite"] from the user's ~/.claude.json with
+  // a raw writeFileSync (no tmp+rename, no backup), which the repo's own test
+  // documents as intentionally one-shot: "If a user later runs `claude mcp add
+  // mem ...` themselves, the gate intentionally lets it stand." A 30-day sweep
+  // turned that into a recurring purge of a config file we do not own.
+  // The mtime never refreshes (the gate skips the block once the file exists),
+  // so every install older than 30 days would have lost it on the first
+  // SessionStart after upgrading.
+  //
+  // Why it was missed: the search for writers used `grep --include=*.mjs
+  // --include=*.js`, and the writer is a SHELL script. `sentinelPrefixesFromShell`
+  // below now derives this class from scripts/*.sh instead of from memory.
+  '.mcp-dedup-',
+  '.residue-warned-',
 ]);
 
+/**
+ * Marker-name prefixes that scripts/*.sh treats as one-shot sentinels, derived
+ * from the shell source rather than restated here. `tests/runtime-marker-gc`
+ * asserts none of them is GC-able: a shell-written sentinel is invisible to a
+ * JS-only grep, which is exactly how `.mcp-dedup-` reached the GC list.
+ *
+ * @param {string} shellSource concatenated contents of scripts/*.sh
+ * @returns {string[]} prefixes like `.mcp-dedup-`
+ */
+export function sentinelPrefixesFromShell(shellSource) {
+  const out = new Set();
+  // Matches `"$DATA_DIR/runtime/.mcp-dedup-v2.78"` and friends: a dotfile under
+  // runtime/ whose name carries a version-ish suffix.
+  for (const m of String(shellSource || '').matchAll(/runtime\/(\.[a-z0-9-]*?-)v?[0-9][0-9.]*/gi)) {
+    out.add(m[1]);
+  }
+  return [...out];
+}
+
 /**
  * Sweep per-project runtime markers older than `ageMs`. fs-only, best-effort,
  * never throws. Returns the number of files removed.
@@ -287,16 +318,10 @@ export async function callLLM(prompt, timeoutMs = BG_LLM_TIMEOUT_MS) {
 
   const { cli: modelName } = resolveModelShared();
   try {
-    // Same headless-tax flags as haiku-client.mjs#callModelCLI (rationale
-    // there): no transcript persistence, no claudemd hook fan-out.
-    const result = execFileSync(getClaudePathShared(), ['-p', '--model', modelName, '--no-session-persistence'], {
-      input: _flattenForCLI(prompt),
-      timeout: timeoutMs,
-      encoding: 'utf8',
-      env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1', DISABLE_CLAUDEMD_HOOKS: '1' },
-      stdio: ['pipe', 'pipe', 'pipe'],
-      cwd: '/tmp', // Prevent ghost sessions in user's /resume list
-    });
+    // Shared runner with haiku-client.mjs#callModelCLI (rationale there): no
+    // transcript persistence, no claudemd hook fan-out, and the one-shot
+    // retry-without-flag that keeps this leg alive on an older Claude Code CLI.
+    const result = execClaudeCliSync(modelName, { input: _flattenForCLI(prompt), timeout: timeoutMs });
     return result.trim();
   } catch (e) {
     const out = _extractResponseFromError(e);

package/hook.mjs

@@ -54,6 +54,7 @@ import { snapshotDb } from './lib/db-backup.mjs';
 import {
   extractCitationsFromTranscript,
   extractAllInjected,
+  extractInjectedFromKeyContext,
   bumpCitationAccess,
   computeCiteRecall,
   applyCitationDecay,
@@ -740,19 +741,26 @@ async function handleStop() {
             // filter as citedMain (the numerator, below) — an obs injected only
             // inside a subagent (sidechain) would otherwise enter the denominator
             // but never the numerator and streak-demote despite being used there.
-            // runtimeDir + project enable the 5th (Key Context) face — see
-            // extractInjectedFromKeyContext: it is marker-derived, because the
-            // SessionStart block leaves no hook attachment to parse.
-            const injected = extractAllInjected(transcriptPath, {
-              mainOnly: true, runtimeDir: RUNTIME_DIR, project, sessionId: ccSessionId,
-            });
+            const injected = extractAllInjected(transcriptPath, { mainOnly: true });
             // P5 ①: cite-back signals — observations whose warned file the agent
             // edited this session. Union into injected so they're resolved (they
             // were injected via pre-tool-recall) and, below, into cited so the
             // edit promotes them even without a literal #NN in text.
             const citeBackIds = extractCiteBackSignals(transcriptPath);
             for (const id of citeBackIds) injected.add(id);
-            if (injected.size > 0) {
+            // D#124, promotion-only (v3.66.1): the SessionStart Key Context block
+            // leaves no hook attachment, so its ids come from the per-session
+            // marker. They are added to the decay set ONLY where they were
+            // actually cited (below), never as bare denominator: the block
+            // re-renders the same fixed top-10 unconditionally, so an uncited
+            // render says nothing about relevance — and since keyObs gates on
+            // `importance >= 2`, one demotion evicts the common importance-2 row
+            // from Key Context for good. v3.66.0 fed them in as denominator and
+            // that made the block eat its own contents.
+            const keyCtxIds = extractInjectedFromKeyContext({
+              runtimeDir: RUNTIME_DIR, project, sessionId: ccSessionId,
+            });
+            if (injected.size > 0 || keyCtxIds.size > 0) {
               // Text-floor gate: skip decay on tool-only Stops. Without this,
               // a turn that ends on tool_use locks every injected obs as
               // uncited (last_decided_session_id set), so a later turn that
@@ -765,6 +773,10 @@ async function handleStop() {
               } else {
                 const citedMain = extractCitationsFromTranscript(transcriptPath, { mainOnly: true });
                 for (const id of citeBackIds) citedMain.add(id);
+                // The promotion-only half: a Key Context row the agent actually
+                // cited joins the decay set (and takes the promote branch); one
+                // it ignored is never entered, so it cannot streak or demote.
+                for (const id of keyCtxIds) if (citedMain.has(id)) injected.add(id);
                 // D#60: the idempotency key must be the CC session UUID, NOT the
                 // project-scoped memory sessionId — concurrent same-project CC
                 // sessions share the latter, so the second session's decay pass

package/lib/citation-tracker.mjs

@@ -356,8 +356,20 @@ export function extractInjectedFromFyi(transcriptPath, opts = {}) {
  * sections never appear).
  *
  * Session-gated: a marker whose recorded session differs from the caller's is
- * another window's render and must not enter this session's denominator. No
- * coordinates → empty set, so transcript-only callers keep their old behaviour.
+ * another window's render and must not be attributed to this session.
+ *
+ * PROMOTION-ONLY (v3.66.1). Deliberately NOT part of extractAllInjected: the
+ * other four faces are query-conditioned — a row appears there because it
+ * MATCHED something, so its absence from the cited set is evidence it was not
+ * useful. A Key Context render is unconditional and re-renders the same fixed
+ * top-10 every session, so an uncited render is evidence of nothing but elapsed
+ * time. Feeding these ids into the decay DENOMINATOR made the block consume
+ * itself: keyObs gates on `importance >= 2` (hook-context.mjs), and a demotion
+ * takes the common importance-2 row to 1, dropping it out of Key Context
+ * permanently after 3 uncited sessions — each departure promoting the next row
+ * into the same grinder. Callers must therefore intersect with the cited set
+ * (see handleStop) so a CITED Key Context row is credited while an uncited one
+ * is left alone.
  *
  * @param {object} [ctx]
  * @param {string} [ctx.runtimeDir]
@@ -378,21 +390,22 @@ export function extractInjectedFromKeyContext({ runtimeDir, project, sessionId =
 }
 
 /**
- * Union of every injection surface's IDs for a transcript: pre-tool-recall +
- * UserPromptSubmit `<memory-context>` + PostToolUse error-recall + the
- * user-prompt-search FYI block + the SessionStart Key Context block. Single
- * integration point the Stop handler calls.
+ * Union of the QUERY-CONDITIONED injection surfaces for a transcript:
+ * pre-tool-recall + UserPromptSubmit `<memory-context>` + PostToolUse
+ * error-recall + the user-prompt-search FYI block. Single integration point the
+ * Stop handler calls for the decay DENOMINATOR.
+ *
+ * Key Context is intentionally absent (v3.66.1 — it was unioned here for one
+ * release): every face above appears because a row matched something, so an
+ * uncited appearance carries relevance information. An unconditional
+ * SessionStart render does not. Callers wanting the Key Context ids ask
+ * `extractInjectedFromKeyContext` directly and use them promotion-only.
  *
  * @param {string|null|undefined} transcriptPath
  * @param {object} [opts]
  * @param {boolean} [opts.mainOnly=false] Skip sidechain-injected IDs. The
  *   citation-decay caller passes true so the injected denominator matches the
  *   mainOnly cited numerator; the P4 access-bump caller omits it (broader).
- * @param {string} [opts.runtimeDir] With `project`, enables the Key Context
- *   face. Omitted by callers that only have a transcript path (computeCiteRecall
- *   over an arbitrary file), which then see the four transcript-derived faces.
- * @param {string} [opts.project]
- * @param {string|null} [opts.sessionId]
  * @returns {Set<number>}
  */
 export function extractAllInjected(transcriptPath, opts = {}) {
@@ -401,9 +414,6 @@ export function extractAllInjected(transcriptPath, opts = {}) {
     ...extractInjectedFromUserPromptSubmit(transcriptPath, opts),
     ...extractInjectedFromErrorRecall(transcriptPath, opts),
     ...extractInjectedFromFyi(transcriptPath, opts),
-    // Marker-derived, not transcript-derived: no-op unless the caller passes
-    // runtimeDir + project (see extractInjectedFromKeyContext).
-    ...extractInjectedFromKeyContext(opts),
   ]);
 }
 

package/lib/keyctx-marker.mjs

@@ -42,21 +42,24 @@ export function recordKeyContextInjection(db, { runtimeDir, project, sessionId =
     if (Number.isInteger(id) && id > 0 && id < 1e7) clean.push(id);
   }
 
-  let bumped = 0;
-  if (db && clean.length > 0) {
-    try {
-      const now = Date.now();
-      // Mirrors hook-memory.mjs's UPS bump verbatim so the two surfaces feed the
-      // same counter with the same semantics. Per-row try/catch for FTS trigger
-      // safety (project_non_obvious.md).
-      const stmt = db.prepare(
-        'UPDATE observations SET injection_count = COALESCE(injection_count, 0) + 1, last_injected_at = ? WHERE id = ?'
-      );
-      for (const id of clean) {
-        try { stmt.run(now, id); bumped++; } catch { /* single-row failure must not drop the rest */ }
-      }
-    } catch (e) { debugCatch(e, 'keyctx-bump'); }
-  }
+  // NO injection_count bump. v3.66.0 added one here and it had to be reverted in
+  // v3.66.1: injection_count is not a neutral counter. scoring-sql.mjs states the
+  // invariant — "bumped ONLY on UserPromptSubmit / hook-memory auto-inject" —
+  // because noisePenaltyClause reads it as a NOISE signal: a row scores x0.5 once
+  // injection_count >= 4 (and > access_count * 3), x0.2 at >= 8. Nothing bumps
+  // access_count for a rendered row (bumpCitationAccess fires on CITED ids only),
+  // so the counter crosses those thresholds purely as a function of elapsed
+  // sessions, deprioritising the highest-importance rows — the exact rows Key
+  // Context renders — in mem_search, UPS ranking and injectionRelevanceSql.
+  //
+  // The UPS bump the reverted code claimed to "mirror verbatim" is
+  // query-conditioned: a row is counted only when it MATCHED a query, so the
+  // counter means "auto-injected and never useful". A Key Context render is
+  // unconditional and hits the same fixed row set every session, so it would have
+  // measured nothing but time. D#124's requirement is decay reachability, which
+  // the extractor face delivers on its own — decay reads decay_seen_count /
+  // uncited_streak / cited_count, never injection_count.
+  const bumped = 0;
 
   let written = false;
   try {

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.66.0",
+  "version": "3.66.2",
   "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",