claude-mem-lite 3.86.0 → 3.88.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.86.0",
+      "version": "3.88.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.86.0",
+  "version": "3.88.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

@@ -841,7 +841,7 @@ benchmark and A/B harness are calibrated against — changing them invalidates t
 |----------|-------------|---------|
 | `CLAUDE_MEM_NO_CITATION_TRACK` | `1` disables both the access-count bump and the decay loop — no citation bookkeeping at all. | _(enabled)_ |
 | `MEM_DISABLE_CITATION_DECAY` | `1` disables only the decay writes, keeping access-count bumps. | _(enabled)_ |
-| `CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD` | Session cite-rate below which demotion is suppressed (promotion always proceeds). | `0.02` |
+| `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_MIN_INJECTED` | Minimum injection volume before the ratio gate is judged at all. | `5` |

package/hook-context.mjs

@@ -9,7 +9,7 @@ import { basename, join } from 'path';
 import { existsSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'fs';
 import {
   estimateTokens, truncate, typeIcon, fmtTime, inferProject,
-  debugLog, debugCatch, neutralizeContextDelimiters,
+  debugLog, neutralizeContextDelimiters,
   DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, notLowSignalTitleClause,
 } from './utils.mjs';
 import { STALE_SESSION_MS, FALLBACK_OBS_WINDOW_MS, RUNTIME_DIR, effectiveQuiet, isQuietHooks, KEY_CONTEXT_LIMIT } from './hook-shared.mjs';
@@ -70,12 +70,56 @@ export function computeAdaptiveWindows(db, project) {
 // however well it scores.
 //
 // Named rather than inline so benchmark/keyctx-pool-replay.mjs can patch a twin and
-// price a change to them. Extracting them changed no value.
+// price a change to them. Keep the `export const NAME = <int>;` shape — that ruler
+// patches the DECLARATION by regex and throws when the anchor moves.
 //
-// NOT yet widened: SessionStart injects on every start, so moving these is a
-// user-visible default-behaviour change to a released artifact (L3) and gets its own
-// round. Measured truncation as of 2026-09-01 is in the replay's header.
-export const KEYCTX_POOL_OBS = 50;
+// OBS was 50 through v3.86.0 and is now an OOM backstop, not a relevance gate. What the
+// ruler measured before the change (2026-09-02T06:11Z, 11 projects with >=20 live rows,
+// budget 2000, AGAINST THE 50/10 TREE — reproduce with `--population --ref-obs 50
+// --ref-sess 10` and with `--wide-obs 50 --wide-sess 10`, which runs the comparison
+// backwards; the bare command now reports 0/11 because shipped is the wider bound):
+// the 50-row bound truncated the pool in 3 of 11 projects, and lifting it
+// alone moved the injected block in 2 of 11 — 8 rows newly reachable against 2 displaced,
+// for +81 and +16 tokens. Selection here is NOT monotone, so a displaced row is a real
+// cost and the ruler prints it as a first-class number (`--why-displaced` names the rows
+// and the gate that dropped each).
+//
+// Both displaced rows lost their slot to the 3-per-type diversity cap. That is not a
+// three-way discrimination: the token budget does not bind on this corpus (651 of 2000 in
+// the widest arm's largest project) and the file-overlap `continue` that used to sit in
+// the selector was UNREACHABLE and has since been deleted (D#197) — so the cap is
+// currently the only gate that can fire. ("below" until v3.88.0; there is nothing below
+// any more, and a reader who went looking found the sentence outliving its referent.)
+//
+// 200 is ~2x the largest pool observed (107). The ruler CANNOT distinguish 200 from 500
+// on this corpus — every bound >= the largest pool is one arm, identical in both
+// selection and cost — so this value is a headroom choice, not a measured optimum.
+// computeAdaptiveWindows NARROWS the windows as velocity rises (tier3 60d -> 30d -> 14d),
+// so activity counteracts pool growth instead of driving it: the largest pool here is the
+// lowest-velocity high-volume project (1.14 obs/day, 107 rows) while the only project a
+// band up has 2.9x the velocity and 29% of the pool. A draft of this comment had that
+// backwards.
+//
+// Cost is PER PROJECT: ~2.7x where the pool is 107, ~2.0x at 59, ~1.5x at 62, and
+// unchanged (inferred, not measured) for the eight projects whose pool never reached 50.
+// Once per SessionStart, both arms in the low single-digit milliseconds. It is NOT a clean
+// function of pool growth — the 59-row project grows less than the 62-row one and costs
+// more, on two independent harnesses, because fixed per-call work (SQL fetch,
+// estimateTokens, JSON.parse, the unchanged summary half) sets the denominator. Three
+// drafts were wrong here in three ways: a point estimate (2.65x), a global range
+// (2.1x-3.8x) no measurement produced, and a causal claim n=3 refutes. Absolute
+// milliseconds are not quotable. Re-derive with `--cost --wide-obs 50 --wide-sess 10
+// --project <p>`, which prices the widening in the correct direction.
+//
+// SESS stays 10 DELIBERATELY, and the discriminator is `sessDisplaced = 0` in 11 of 11
+// projects, not the observation column. Widening it to 40 displaces no summary at all —
+// it is PURELY ADDITIVE, so that LIMIT is a volume cap and not the D#172 shape, which is
+// the actual reason it does not need lifting. (It also changed zero observations, but
+// that only says the obs side is unaffected.) What widening does buy is 130 newly injected
+// summaries, roughly tripling the emitted block on the largest projects. It truncates MORE
+// projects than the obs bound, 5 of 11 against 3 of 11, which is what made the original
+// review propose it first; truncation count is not harm.
+export const KEYCTX_POOL_OBS = 200;
 export const KEYCTX_POOL_SESS = 10;
 
 /**
@@ -154,7 +198,6 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
     ...scoredSess.map(s => ({ ...s, _kind: 'sess' })),
   ].sort((a, b) => b.valueDensity - a.valueDensity);
 
-  const selectedFiles = new Set();
   const selectedTypes = new Map(); // type → count for diversity constraint
 
   for (const c of allCandidates) {
@@ -166,20 +209,32 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
       if (typeCount >= 3) continue;
     }
 
-    // Diversity penalty: reduce value for file overlap with already-selected
-    if (c._kind === 'obs' && c.files_modified) {
-      let cFiles;
-      try { cFiles = JSON.parse(c.files_modified || '[]'); } catch (e) { debugCatch(e, 'budgetSelect-parseFiles'); cFiles = []; }
-      if (cFiles.length > 0 && selectedFiles.size > 0) {
-        const overlap = cFiles.filter(f => selectedFiles.has(f)).length;
-        const overlapRatio = overlap / cFiles.length;
-        const penalizedValue = c.valueDensity * (1 - 0.3 * overlapRatio);
-        if (penalizedValue < 0.001) continue;
-      }
-      for (const f of cFiles) selectedFiles.add(f);
-    }
-
-    // Commit type diversity counter after both gates pass
+    // D#197: a "Diversity penalty: reduce value for file overlap" block used to sit
+    // here. It is gone, and the deletion is behaviour-preserving, because it reduced
+    // nothing. Two independent reasons, both verified rather than reasoned about:
+    //
+    //  (1) Its `penalizedValue` was a local read by exactly one `continue`. Order was
+    //      already fixed upstream by the raw-valueDensity sort and this greedy loop
+    //      never re-sorts — so the comment's promise could not happen at all.
+    //  (2) That `continue` was unreachable. penalizedValue >= 0.7 * valueDensity, and
+    //      valueDensity = value / sqrt(cost) with value > 0.5 (recency > 1 x
+    //      TYPE_QUALITY min 0.5 x impBoost >= 1.0 x lessonBoost >= 1.0) and cost >= 1
+    //      — estimateTokens('') returns 1, checked, so there is no zero-cost row that
+    //      would drive valueDensity to 0 and make it fire. Triggering needed a title
+    //      costing > 122500 tokens. Measured over the 2027 live rows carrying
+    //      files_modified: zero zero-cost rows, minimum valueDensity 0.1147 (80x the
+    //      trigger), longest title 171 chars = 43 tokens by this code's own
+    //      estimateTokens (ceil(ascii/4) + ceil(cjk/1.5)). A first version of this line
+    //      said 49, which is 3.5 chars/token — a rate nothing here uses.
+    //
+    // With both gone `selectedFiles` had no reader left, so the Set and its
+    // JSON.parse went with it. Type diversity above is the only diversity constraint
+    // that was ever live, which is why the counter below no longer says "both gates".
+    //
+    // Real overlap down-weighting, if wanted, belongs in the sort key — a ranking
+    // change owing an A/B, not a revival of this block. tests/hook-context.test.mjs
+    // pins the current unpenalized order and asserts its own discriminator, so a
+    // penalty that reached the ordering turns red instead of landing silently.
     if (c._kind === 'obs' && c.type) {
       selectedTypes.set(c.type, (selectedTypes.get(c.type) || 0) + 1);
     }

package/hook-memory.mjs

@@ -31,8 +31,11 @@ const MEMORY_LOOKBACK_MS = 60 * DAY_MS; // 60 days
  * × 3.0 cite = 6.75; worst = 0.5 change × 1.0 no-lesson × 0.6 importance × 0.2 noise ×
  * 0.4 cite = 0.024, i.e. a **281× DECLARED range**. That is an upper bound off the factor
  * tables, not a measurement: `citeFactor = 0.4` requires `uncited_streak >= 3`, and
- * citation-decay resets the streak at 3 after demoting importance, so the steady state is
- * bounded by [0,2] (scoring-sql.mjs, citeFactorJs docblock). Measured 2026-09-01 over the
+ * citation-decay rolls the streak over to 0 when it reaches 3, so the steady state is
+ * bounded by [0,2] (scoring-sql.mjs, citeFactorJs docblock). That rollover used to be
+ * paired with an `importance - 1`; D#179/D#198 removed the importance write, and the
+ * bound is unaffected because it was always the streak reset that produced it.
+ * Measured 2026-09-01 over the
  * 2284 rows that clear `liveObsFilterSql` — the one predicate in the WHERE of BOTH SELECTs
  * below — 0 are at streak >= 3, and recomputing the factor per row gives a REALISED range
  * of 0.1125 … 6.750: a **60.0× spread** (81 rows hit the full best case, 0 the full worst).
@@ -513,9 +516,13 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
  * projects on this machine the importance=3 population ALONE exceeds 50 — so every
  * importance=2 lesson in those projects was structurally unreachable, and a
  * citation-decay demotion 3->2 EVICTED a row from the pool instead of down-ranking it.
- * That eviction loop is the risk D#172 was filed on; raising the bound above any
- * plausible per-project population is what closes it, because a 3->2 demotion then only
- * changes the row's score multiplier, which is what the decay design intends.
+ * That eviction loop is the risk D#172 was filed on, and raising the bound above any
+ * plausible per-project population is what closed it. The second half of that sentence
+ * is now moot from the other end too: D#179/D#198 stopped citation-decay writing
+ * `importance` at all, so there is no 3->2 walk left for the bound to have to absorb.
+ * The bound still matters on its own terms — it is what makes importance=2 rows
+ * reachable here — but it is no longer the only thing standing between a citation and
+ * an eviction.
  *
  * COUNT THE POPULATION WITH THE POOL'S OWN FILTER. Those figures are
  * `liveObsFilterSql` + the `importance >= 2` + non-empty-lesson gates, i.e. what the query
@@ -527,14 +534,17 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
  * in lib/citation-tracker.mjs. Re-measure with `node benchmark/imperative-pool-replay.mjs
  * --population`, never with a bare `SELECT ... WHERE importance = 3`.
  *
- * 3->2 IS NOW A DOWN-RANK; 2->1 IS STILL AN EVICTION. The pool gate is
- * `COALESCE(importance, 1) >= 2`, so a row demoted to the IMPORTANCE_FLOOR of 1 leaves
- * this face's reach until some other face cites it back up. Widening the bound is also
- * what first makes importance=2 rows reachable here (56 of projects--mem's 383 eligible),
- * so it creates the injections that can walk one down to 1. Measured exposure: of the
- * picks the widening newly surfaces, one is importance=2 — `score = importance x overlap`
- * keeps importance=3 rows ahead nearly always — so this is a known small edge, not a
- * closed loop.
+ * THE EVICTION EDGE IS CLOSED FROM THE OTHER END, AND NOT BY THIS BOUND. The pool gate is
+ * `COALESCE(importance, 1) >= 2`, so a row at 1 is out of this face's reach — that part is
+ * unchanged. What changed is that nothing in the citation loop can put it there any more:
+ * D#179/D#198 deleted the `importance` write from BOTH branches of `applyCitationDecay`
+ * along with `IMPORTANCE_FLOOR` itself, so neither a 3->2 down-rank nor a 2->1 eviction can
+ * originate from a citation. This paragraph used to read "3->2 IS NOW A DOWN-RANK; 2->1 IS
+ * STILL AN EVICTION" and cite that constant; it survived the deletion because the paragraph
+ * immediately above it was the one rewritten (pre-tag review v3.88.0, correctness S3).
+ * What can still move a row to 1 is ordinary maintenance — `demotePinned` writes 1 on a
+ * heavily-injected uncited row with no lesson, and `decayAndMarkIdle` walks `imp - 1` on a
+ * never-accessed never-injected row — so the edge exists, it just is not citation-driven.
  *
  * MEASURED, and reproducible: `node benchmark/imperative-pool-replay.mjs`. Over 373 real
  * user prompts replayed against their OWN project's live corpus (85 produced a candidate

package/hook.mjs

@@ -1004,10 +1004,14 @@ async function handleStop() {
             // 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.
+            // render says nothing about relevance. v3.66.0 fed them in as
+            // denominator and that made the block eat its own contents.
+            // The policy used to rest on a second ground as well — "since keyObs
+            // gates on `importance >= 2`, one demotion evicts the common
+            // importance-2 row from Key Context for good" — which D#179/D#198
+            // retired: this loop no longer writes `importance`, so no citation
+            // miss can evict anything. The first ground is untouched and is why
+            // the policy stays.
             const keyCtxIds = extractInjectedFromKeyContext({
               runtimeDir: RUNTIME_DIR, project, sessionId: ccSessionId,
             });

package/lib/citation-tracker.mjs

@@ -830,13 +830,14 @@ export function extractAllInjected(transcriptPath, opts = {}) {
  *   changed the top-1 in 3 of 78. The bound is now IMPERATIVE_POOL_BACKSTOP = 5000,
  *   documented there as an OOM backstop and not a relevance gate.
  *
- *   A 3->2 demotion is a down-rank again. A 2->1 demotion is still an EVICTION, because
- *   the pool gate is `>= 2` and IMPORTANCE_FLOOR is 1 — and widening is what first makes
- *   importance=2 rows reachable by this face at all, so it creates the injections that can
- *   walk one there. Measured exposure is one row; see the constant's docblock. `subagent`
- *   shares that pool and inherits both halves. Still open in D#172: admitting `subagent`
- *   to the denominator, which is a separate decision needing the receiver-attributed cites
- *   merged asymmetrically.
+ *   The demotion half of that paragraph is now MOOT rather than merely improved:
+ *   D#179/D#198 stopped this loop writing `importance` at all, so neither a 3->2 nor a
+ *   2->1 walk can happen through decay and the pool gate `>= 2` is no longer something
+ *   citations move a row across. The widening still matters on its own terms — it is
+ *   what makes importance=2 rows reachable by this face — but the eviction risk it used
+ *   to carry is gone with the writes. `subagent` shares that pool. Still open in D#172:
+ *   admitting `subagent` to the denominator, which is a separate decision needing the
+ *   receiver-attributed cites merged asymmetrically.
  */
 const DECAY_EXCLUDED_SURFACES = new Set();
 
@@ -906,21 +907,32 @@ export const DECAY_DENOMINATOR_SURFACES = ATTACHMENT_SURFACES.filter((f) => !DEC
  *   FOUR of the five are 3->2 down-ranks (#8597, #8847 with cited_count 56, #8948,
  *   #10246). THE FIFTH WAS AN EVICTION and the first draft of this note said there were
  *   none: at 2026-08-25 18:00Z, #10716 sat at importance = 2, so its next miss would take
- *   it to IMPORTANCE_FLOOR = 1 — under the `COALESCE(importance, 1) >= 2` gate in
+ *   it to the floor of 1 (`IMPORTANCE_FLOOR`, a constant this loop no longer has — see the
+ *   correction two paragraphs down) — under the `COALESCE(importance, 1) >= 2` gate in
  *   rankImperativeCandidates, which is the candidate pool of the very face being
  *   admitted. IMPERATIVE_POOL_BACKSTOP closed the 3->2 eviction in v3.82.0 and 2->1 was
  *   always documented as still evicting; writing "down-ranks, not evictions" required
  *   assuming the marginal population was all importance = 3, which one query refutes.
  *   Count it before repeating it.
  *
- *   THAT ROW IS NO LONGER IN THAT STATE, AND THE REASON IS THIS LOOP (D#179). #10716 now
- *   reads importance 3 / uncited_streak 0 / demoted_at cleared, promoted by the session
- *   that WROTE THIS PARAGRAPH: `#10716` occurs 21 times in that session's assistant text,
- *   extractCitationsFromTranscript scans assistant text for `#NN`, and applyCitationDecay
- *   promotes on a hit. Discussing a memory is indistinguishable from applying it here.
- *   Anything in this file that quotes live decay STATE is therefore perturbed by being
- *   written down; quote it with a timestamp, and prefer the structural claim (the marginal
- *   population is not all importance = 3) to the row that demonstrated it.
+ *   THAT ROW WAS NO LONGER IN THAT STATE, AND AT THE TIME THE REASON WAS THIS LOOP (D#179).
+ *   #10716 read importance 3 / uncited_streak 0 / demoted_at cleared, promoted by the
+ *   session that WROTE THIS PARAGRAPH: `#10716` occurs 21 times in that session's assistant
+ *   text, extractCitationsFromTranscript scans assistant text for `#NN`, and at that time
+ *   applyCitationDecay raised `importance` on a hit. Discussing a memory was
+ *   indistinguishable from applying it.
+ *
+ *   CORRECTED (v3.88.0, D#179/D#198): that mechanism is gone. Neither branch of this loop
+ *   writes `importance` any more, so citing a row cannot promote it HERE and the specific
+ *   self-promotion described above can no longer occur. Two things still hold and are the
+ *   reason the paragraph is kept rather than deleted. The general warning stands — anything
+ *   in this file quoting live decay STATE is perturbed by being written down, since the
+ *   loop still writes `cited_count`, `uncited_streak`, `demoted_at` and the session
+ *   columns on a citation — so quote it with a timestamp and prefer the structural claim
+ *   (the marginal population is not all importance = 3) to the row that demonstrated it.
+ *   And a citation can still reach `importance` by a SECOND path this loop does not own:
+ *   `bumpCitationAccess` credits `access_count`, and the `boost` maintain op raises
+ *   `importance` by 1 above `access_count > 3` (D#206, open).
  *
  *   Cross-crediting — a main-face id the main thread never cited but a subagent did — is
  *   3 pairs. The denominator giving 0.25% is DISTINCT (session,id) across the five decay
@@ -1170,54 +1182,40 @@ export function hasMainThreadAssistantText(transcriptPath) {
   return false;
 }
 
-const IMPORTANCE_CAP = 3;
-// Demote floor = 1, NOT 0. Both passive injection surfaces exclude importance 0
-// (pre-tool-recall.js requires >=2, user-prompt-search.js requires >=1), so a row
-// demoted to 0 can never be re-injected → never re-cited → never recovers: a one-way
-// burial that silently hides lesson-bearing rows the "lessons never auto-GC" guards
-// (maintain decayAndMarkIdle + compress-core) protect on every other path. Floor 1
-// keeps a decayed row on the >=1 surface with a citation-recovery path. Genuine noise
-// still sinks via maintain's PENDING_PURGE pipeline, which keys on compressed_into
-// (not importance) over injection_count=0 rows — a disjoint population from these
-// injected-but-uncited rows — so noise GC is unaffected.
-const IMPORTANCE_FLOOR = 1;
+// IMPORTANCE_CAP (3) and IMPORTANCE_FLOOR (1) lived here until D#179/D#198 took
+// `importance` out of this loop entirely; both are gone rather than kept unused.
+// The reasoning behind the FLOOR is preserved because it is the sharpest statement
+// of why decay must not move this column at all: both passive injection surfaces
+// exclude importance 0 (pre-tool-recall.js requires >= 2, user-prompt-search.js
+// requires >= 1), so a row demoted to 0 could never be re-injected -> never
+// re-cited -> never recover. The floor bounded that one-way burial at the bottom
+// of the scale; it could do nothing about the same mechanism one step up, where
+// a 3 -> 2 evicts a row from the `>= 3` tier arm of the Key Context pool. Genuine
+// noise still sinks via maintain's PENDING_PURGE pipeline, which keys on
+// compressed_into (not importance) over injection_count = 0 rows.
 const UNCITED_STREAK_THRESHOLD = 3;
 
-// Adoption-rate gate (P5 ②). A project's cite-rate is SUM(cited_count) /
-// SUM(decay_seen_count) over its non-superseded observations: of every decay
-// resolution this project has ever produced, what fraction were citations.
-// Below ADOPTION_THRESHOLD with at least ADOPTION_MIN_SEEN resolutions on record,
-// the project has demonstrably not adopted the #NN convention, so we suppress
-// DEMOTION (never promotion) — see the construct-validity note on
-// applyCitationDecay. MIN_SEEN keeps the gate dormant for low-data projects so
-// the established behavior is preserved until there's enough signal to judge.
-const ADOPTION_THRESHOLD = 0.02;
-const ADOPTION_MIN_SEEN = 8;
-
-/**
- * Compute a project's citation-adoption snapshot: total citations vs total decay
- * resolutions on record, and their ratio. Read-only; safe to call before the
- * decay transaction (the gate decision is made on the pre-mutation snapshot).
- *
- * @param {import('better-sqlite3').Database} db
- * @param {string} project
- * @returns {{cited: number, seen: number, rate: number}}
- */
-export function computeCitationAdoption(db, project) {
-  const empty = { cited: 0, seen: 0, rate: 0 };
-  if (!db || !project) return empty;
-  try {
-    const row = db.prepare(`
-      SELECT COALESCE(SUM(cited_count), 0)       AS cited,
-             COALESCE(SUM(decay_seen_count), 0)  AS seen
-        FROM observations
-       WHERE project = ? AND superseded_at IS NULL
-    `).get(project);
-    const cited = row?.cited || 0;
-    const seen = row?.seen || 0;
-    return { cited, seen, rate: seen > 0 ? cited / seen : 0 };
-  } catch (e) { debugCatch(e, 'computeCitationAdoption'); return empty; }
-}
+// The adoption-rate gate (P5 ②) lived here, with computeCitationAdoption feeding
+// it and a streak CAP as its other half. All three are gone — D#204.
+//
+// It suppressed the demote branch in a project whose cite-rate was ~0 over enough
+// resolutions, on the reasoning that such a project has not adopted the `#NN`
+// convention and a demotion there is a false negative it could never earn back.
+// That reasoning was entirely about `importance`, which D#179 removed from this
+// loop. What was left behind was inverted: the suppressed path capped
+// uncited_streak at threshold-1 and so never returned to 0 without a citation,
+// pinning those projects' rows at citeFactor 0.5x permanently, while an adopting
+// project's rolled back to 1.0x every third resolution. The gate written to be
+// gentler on non-adopting projects had become the only thing punishing them.
+//
+// The cap's stated purpose — keep the streak from climbing unbounded into the
+// citeFactor floor — is served by the rollover itself, and served better, since
+// the rollover also recovers. One path for every project.
+//
+// CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD tuned the gate. It is now inert, and
+// warned about rather than silently ignored (see applyCitationDecay): a setting
+// that is accepted but means nothing is worse than one that is unsupported.
+let adoptionThresholdWarned = false;
 
 /**
  * D#61: a lesson injected live and then superseded mid-session (auto-dedup /
@@ -1264,8 +1262,49 @@ export function redirectSupersededIds(db, project, ids) {
  * Apply the citation-feedback loop for one session: for each injected obs id,
  * decide cited vs uncited and mutate importance/streak/cited_count per spec.
  *
- * - cited: importance += 1 (cap 3), cited_count += 1, streak = 0.
- * - uncited: streak += 1; if it reaches 3, importance -= 1 (floor 1, IMPORTANCE_FLOOR), streak = 0.
+ * - cited: cited_count += 1, streak = 0, demoted_at cleared.
+ * - uncited: streak += 1; if it reaches 3, streak = 0 and demoted_at is stamped.
+ *
+ * D#179 / D#198 — THIS LOOP NO LONGER WRITES `importance`, on any branch.
+ * `importance` was carrying two jobs at once: a relevance prior AND a
+ * pool-admission gate. Every injection surface gates on it — `>= 1` or `>= 2` on
+ * the prompt faces, and hook-context's Key Context tier arms use `>= 1 / >= 2 /
+ * >= 3` — so a decay-driven 3 -> 2 was not a down-rank, it removed the row from
+ * the candidate POPULATION. That is the D#172 shape, confirmed on the imperative
+ * pool (v3.82.0) and then on the Key Context pool, where 45 of ~106 pool rows sat
+ * in the band where one demotion is an eviction (D#198).
+ *
+ * The ranking half of the loop is unaffected and was never the problem:
+ * cited_count and uncited_streak still feed citeFactorClause, a BOUNDED
+ * [0.4, 3.0] pure multiplier. So the feedback loop still responds to observed
+ * agent behaviour — it just does so by re-ranking within the population instead
+ * of by changing who is in it. Given that no available signal separates "acted on
+ * this lesson" from "wrote about this lesson" (D#179; a release-note session
+ * promotes exactly the rows it discusses, and the mention/application split
+ * measured on the live corpus is not a bound in either direction), a bounded rank
+ * shift is the right cost for a mis-read citation. An eviction is not.
+ *
+ * NOT covered by this change, and stated so nobody reads it as "citations can no
+ * longer move importance": `bumpCitationAccess` credits `access_count`, and the
+ * `boost` maintain op lifts `importance + 1` above `access_count > 3`. That is a
+ * SECOND, independent citation -> importance path (obs #10911, D#206).
+ *
+ * Scope it correctly — an earlier version of this paragraph said "for any `#NN` in
+ * assistant text", which has been false since v3.84.0 (f9a9eae). The credit is gated
+ * on `buildCitationRelevanceSet`: the id must have been injected on one of the five
+ * attachment faces, or by Key Context, or into a subagent, or typed by the user. A
+ * bare mention of an id you were never shown credits nothing, and the revert switch
+ * is CLAUDE_MEM_CITATION_RELEVANCE_GATE=off. What the gate does NOT ask is whether
+ * you acted on the lesson — an injected id named only in prose is still credited —
+ * which is why the path is open rather than closed.
+ *
+ * Measured before deciding to leave it (2026-09-02, live DB + 98 transcripts): 52
+ * rows are currently boost-eligible; 25 of them are cited nowhere in the corpus, and
+ * at most 3 could have crossed `access_count > 3` on citations even under an upper
+ * bound that ignores the gate entirely. So the path is real and its effect is small.
+ * It is untouched here because `access_count` has other writers (explicit recall /
+ * get / timeline) and is also an input to noisePenaltyClause, so changing it is a
+ * different decision with a different blast radius.
  * - per-(session, obs) idempotent via last_decided_session_id; re-running for
  *   the same session is a no-op (Stop hook may fire more than once).
  * - cross-project IDs are silently ignored by the WHERE clause.
@@ -1277,13 +1316,17 @@ export function redirectSupersededIds(db, project, ids) {
  *   2. (cite-back) the agent edited a file a prior lesson #NN had warned about —
  *      unioned into citedIds by the Stop handler before this call.
  * Signal 2 was added because signal 1 alone penalizes projects that act on a
- * lesson without typing its id. Even so, both are proxies. For a project that has
- * never cited anything (cite-rate below ADOPTION_THRESHOLD over ≥ADOPTION_MIN_SEEN
- * resolutions), demotion is suppressed: absent any positive signal we cannot
- * distinguish "useless lesson" from "useful lesson in a project that doesn't use
- * the #NN convention," and a false demotion is the costlier error. The gate trades
- * missed demotions (stale lessons linger) for avoided false demotions. Promotion
- * is never gated — a single citation lifts the project's rate and re-enables decay.
+ * lesson without typing its id. Even so, both are proxies, and nothing available
+ * separates "acted on this lesson" from "wrote about this lesson".
+ *
+ * That imprecision used to be answered with a per-project adoption gate that
+ * suppressed demotion where the cite-rate was ~0. It is gone (D#204), because the
+ * cost it was insuring against — losing `importance`, i.e. dropping out of the
+ * candidate pool — is gone too (D#179). What the proxies can still get wrong is
+ * bounded on its own: a mis-read citation moves citeFactorClause within
+ * [0.4, 3.0] and nothing else. The uncited streak rolls over at
+ * UNCITED_STREAK_THRESHOLD in every project, so a lesson in a project that never
+ * types `#NN` is not driven monotonically downward — it oscillates and recovers.
  *
  * @param {import('better-sqlite3').Database} db
  * @param {string} project
@@ -1303,16 +1346,22 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   injected = redirectSupersededIds(db, project, injected);
   cited = redirectSupersededIds(db, project, cited);
 
-  // Adoption gate (snapshot taken before any mutation this run). Suppress only
-  // demotion; promotion always proceeds. Threshold overridable via env.
-  const adoption = computeCitationAdoption(db, project);
-  const envThreshold = Number.parseFloat(process.env.CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD);
-  const adoptionThreshold = Number.isFinite(envThreshold) && envThreshold >= 0 ? envThreshold : ADOPTION_THRESHOLD;
-  const suppressDemotion = adoption.seen >= ADOPTION_MIN_SEEN && adoption.rate < adoptionThreshold;
+  // D#204: the adoption gate is gone. Its env override is still READ, once, only
+  // to say out loud that it no longer does anything — the alternative is a
+  // setting a user can configure and watch have no effect.
+  if (!adoptionThresholdWarned && process.env.CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD !== undefined) {
+    adoptionThresholdWarned = true;
+    try {
+      process.stderr.write(
+        '[claude-mem-lite] CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD is set but no longer has any effect — '
+        + 'the citation-decay adoption gate was removed (D#204). Unset it.\n'
+      );
+    } catch (e) { debugCatch(e, 'adoption-threshold-warn'); }
+  }
 
   const selectStmt = db.prepare(
-    // superseded_at IS NULL: mirror computeCitationAdoption + the 4 injection SELECTs so a
-    // row superseded mid-session (injected live, then auto-dedup supersedes it before this
+    // superseded_at IS NULL: mirror the 4 injection SELECTs so a row superseded
+    // mid-session (injected live, then auto-dedup supersedes it before this
     // decay resolves) is not decayed/streaked/mutated — defense-in-depth parity.
     'SELECT id, importance, uncited_streak, last_decided_session_id, last_cited_session_id FROM observations WHERE id = ? AND project = ? AND superseded_at IS NULL'
   );
@@ -1341,8 +1390,7 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   // list would silently renumber if a clause were ever reordered.
   const updatePromote = db.prepare(`
     UPDATE observations
-       SET importance = MIN(@cap, COALESCE(importance, 1) + 1),
-           cited_count = cited_count + 1,
+       SET cited_count = cited_count + 1,
            uncited_streak = 0,
            demoted_at = NULL,
            last_decided_session_id = @session,
@@ -1361,22 +1409,16 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
            decay_seen_count = decay_seen_count + 1
      WHERE id = ?
   `);
-  // Suppressed (non-adopting) projects never demote, so uncited_streak would grow
-  // UNBOUNDED — and citeFactorClause penalizes -0.25*streak (floor 0.4), pinning every
-  // memory at the ranking floor with no recovery path. Cap at UNCITED_STREAK_THRESHOLD-1
-  // to hold the [0, threshold-1] steady state the scoring header asserts (in an adopting
-  // project the streak resets to 0 on demote, so the STORED value never exceeds 2).
-  const updateStreakCapped = db.prepare(`
-    UPDATE observations
-       SET uncited_streak = MIN(uncited_streak + 1, ?),
-           last_decided_session_id = ?,
-           decay_seen_count = decay_seen_count + 1
-     WHERE id = ?
-  `);
+  // D#179/D#198: this branch no longer touches `importance`. It is the STREAK
+  // ROLLOVER: at UNCITED_STREAK_THRESHOLD the streak resets to 0 and the moment
+  // is stamped in demoted_at. The name and the returned `demoted` counter are
+  // kept because both are load-bearing for callers and citation-stats; what
+  // changed is that the rollover is now a bookkeeping event, not a change of
+  // population membership. Resetting the streak (rather than pinning it) is what
+  // holds citeFactorClause's documented [0, threshold-1] steady state.
   const updateDemote = db.prepare(`
     UPDATE observations
-       SET importance = MAX(?, COALESCE(importance, 1) - 1),
-           uncited_streak = 0,
+       SET uncited_streak = 0,
            last_decided_session_id = ?,
            demoted_at = ?,
            decay_seen_count = decay_seen_count + 1
@@ -1403,7 +1445,7 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
         // decay_seen_count and the funnel's injected_n (cite-rate would read N/2, not N/1).
         const firstResolution = !decidedThisSession;
         updatePromote.run({
-          cap: IMPORTANCE_CAP, session: sessionId, seenInc: firstResolution ? 1 : 0, id,
+          session: sessionId, seenInc: firstResolution ? 1 : 0, id,
         });
         promoted++;
         if (firstResolution) touched++;
@@ -1413,15 +1455,12 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
         if (decidedThisSession) continue;
         touched++;
         const nextStreak = (row.uncited_streak || 0) + 1;
-        // Demote only when the streak is up AND the project has demonstrably
-        // adopted citations. A non-adopting project advances the streak (idempotent
-        // bookkeeping) but never loses importance — see construct-validity note.
-        if (nextStreak >= UNCITED_STREAK_THRESHOLD && !suppressDemotion) {
-          updateDemote.run(IMPORTANCE_FLOOR, sessionId, Date.now(), id);
+        // D#204: one path for every project. The rollover both bounds the streak
+        // (so citeFactorClause cannot sink toward its floor) and lets it recover
+        // to 0 without requiring a citation.
+        if (nextStreak >= UNCITED_STREAK_THRESHOLD) {
+          updateDemote.run(sessionId, Date.now(), id);
           demoted++;
-        } else if (suppressDemotion) {
-          // Never-demoting project: cap the streak so cite_factor can't sink to floor.
-          updateStreakCapped.run(UNCITED_STREAK_THRESHOLD - 1, sessionId, id);
         } else {
           updateStreakOnly.run(sessionId, id);
         }