claude-mem-lite 3.87.0 → 3.89.0

package/lib/save-observation.mjs

@@ -18,6 +18,105 @@ import { insertObservationRow, insertObservationFiles, insertObservationVector }
 const DEDUP_WINDOW_MS = 5 * 60 * 1000;
 const DEDUP_RECENT_LIMIT = 50;
 
+/** Human-readable cause per `supersedeSkipped` reason (D#201). */
+const SUPERSEDE_SKIP_CAUSE = {
+  'malformed-id': 'not a positive integer id',
+  'no-such-observation': 'no observation with that id',
+  'no-such-event': 'no event with that id',
+  'other-project': 'belongs to a different project',
+  'already-superseded': 'already superseded (no-op)',
+  'duplicate-save': 'the save deduped, so nothing was superseded',
+};
+
+/**
+ * Split `--supersedes` tokens into the two tables they can name (D#205).
+ *
+ * `E#<n>` addresses the `events` table, matching the prefix those rows are
+ * RENDERED with in the injected lessons block since D#202 — so a reader who sees
+ * `E#10524` can retire it by typing back exactly what they read. A bare number
+ * stays an observation id: observations are the incumbent namespace, and the same
+ * asymmetry is already how `lib/injected-ids.mjs` writes the shared marker file.
+ *
+ * Anything else is malformed and is REPORTED rather than dropped — D#201's whole
+ * point, and the reason this returns the caller's original token for those.
+ *
+ * @param {Array<any>} raw
+ * @returns {{obs: number[], events: number[], malformed: Array<{id: any, reason: string}>}}
+ */
+export function splitSupersedeTokens(raw) {
+  const obs = new Set();
+  const events = new Set();
+  const malformed = [];
+  for (const t of Array.isArray(raw) ? raw : []) {
+    const s = typeof t === 'string' ? t.trim() : t;
+    const m = typeof s === 'string' ? /^[Ee]#?(\d+)$/.exec(s) : null;
+    if (m) {
+      const n = Number(m[1]);
+      if (Number.isInteger(n) && n > 0) { events.add(n); continue; }
+      // `kind` survives even on the malformed branch, so `E#0` reports as `E#0` and not
+      // `#E#0` — the formatter prefixes by kind, and a doubled prefix on the one line
+      // whose job is to echo what the caller typed reads as a second defect.
+      malformed.push({ id: t, reason: 'malformed-id', kind: 'event' });
+      continue;
+    }
+    const n = Number(s);
+    if (Number.isInteger(n) && n > 0) obs.add(n);
+    else malformed.push({ id: t, reason: 'malformed-id', kind: 'obs' });
+  }
+  return { obs: [...obs], events: [...events], malformed };
+}
+
+/**
+ * Render the D#201 warning for requested-but-not-superseded ids. Lives here
+ * rather than in either face so the CLI and the MCP tool cannot word it
+ * differently or, more to the point, so one of them cannot quietly stop
+ * rendering it.
+ *
+ * D#205: an entry carrying `kind: 'event'` is rendered `E#<id>`, the same prefix the
+ * lessons block shows it under, so the id echoed back is the id the caller typed. The
+ * prefix is added HERE rather than baked into `id` because callers compare `id` against
+ * real row ids; a pre-prefixed string would silently break that.
+ *
+ * @param {Array<{id: any, reason: string, kind?: 'obs'|'event'}>} [skipped]
+ * @returns {string|null} null when nothing was skipped
+ */
+/**
+ * Render the ` Superseded: …` note for a successful save (D#205).
+ *
+ * Lives here for the same reason `formatSupersedeSkipped` does: the CLI and the MCP tool
+ * each hand-built this string, and when events became supersedable one of the two would
+ * have kept printing observations only. This round fixed three separate instances of
+ * "the copy I fixed was not the only copy"; a shared renderer is the form that stops the
+ * fourth. `tests/save-observation-supersedes.test.mjs` sweeps both faces for the call.
+ *
+ * Events render with the `E#` prefix and are listed AFTER observations rather than merged,
+ * because the two tables share an id space and a flat list of bare `#N` would not say
+ * which row was retired.
+ *
+ * @param {{supersededIds?: number[], supersededEventIds?: number[]}} [result]
+ * @returns {string} '' when nothing was superseded (safe to concatenate)
+ */
+export function formatSupersededNote(result) {
+  const obs = result?.supersededIds ?? [];
+  const events = result?.supersededEventIds ?? [];
+  if (obs.length === 0 && events.length === 0) return '';
+  const parts = [...obs.map((i) => `#${i}`), ...events.map((i) => `E#${i}`)];
+  return ` Superseded: ${parts.join(', ')}.`;
+}
+
+export function formatSupersedeSkipped(skipped) {
+  if (!Array.isArray(skipped) || skipped.length === 0) return null;
+  const parts = skipped.map(({ id, reason, kind }) => {
+    // Only a resolved NUMERIC id gets a prefix. A malformed entry carries the caller's
+    // ORIGINAL token, which may already contain its own `#` or `E#` — prefixing that
+    // produced `#E#0` (and, after a first attempt at fixing it, `E#E#0`). Echoing an
+    // unparseable token exactly as typed is also the more useful thing to print.
+    const label = typeof id === 'number' ? `${kind === 'event' ? 'E#' : '#'}${id}` : String(id);
+    return `${label} (${SUPERSEDE_SKIP_CAUSE[reason] || reason})`;
+  });
+  return `⚠ --supersedes: ${parts.length} id(s) NOT superseded — ${parts.join(', ')}.`;
+}
+
 /**
  * Save a new observation if it isn't a near-duplicate of one saved within the
  * last 5 minutes (Jaccard similarity > 0.7 on title or content).
@@ -32,8 +131,24 @@ const DEDUP_RECENT_LIMIT = 50;
  * @param {string[]} [params.files=[]]            File paths to attach (junction table).
  * @param {string|null} [params.lesson_learned]   Caller validates ≤500 chars.
  * @param {Date}   [params.now]                   Override for tests.
- * @returns {{ kind: 'duplicate', existingId: number, project: string, type: string }
- *          | { kind: 'saved', id: number, type: string, project: string, title: string, lessonCaptured: boolean }}
+ * Both result shapes carry `supersededIds` (observations actually tombstoned) and
+ * `supersedeSkipped` (requested but NOT tombstoned, each with a `reason`:
+ * `malformed-id` | `no-such-observation` | `no-such-event` | `other-project` |
+ * `already-superseded` | `duplicate-save`, plus `kind: 'obs'|'event'`). Callers MUST
+ * surface a non-empty `supersedeSkipped` — that is the whole point of D#201; dropping it
+ * puts the silent failure back.
+ *
+ * The `saved` shape also carries `supersededEventIds` (D#205), kept separate rather than
+ * merged: `events` and `observations` share an id space, so one flat list of bare `#N`
+ * could not say which table a retired row came from. Use `formatSupersededNote` to render
+ * both rather than reassembling the string per face.
+ *
+ * @returns {{ kind: 'duplicate', existingId: number, project: string, type: string,
+ *             supersededIds: number[],
+ *             supersedeSkipped: Array<{id: any, reason: string, kind?: string}> }
+ *          | { kind: 'saved', id: number, type: string, project: string, title: string,
+ *              lessonCaptured: boolean, supersededIds: number[], supersededEventIds: number[],
+ *              supersedeSkipped: Array<{id: any, reason: string, kind?: string}> }}
  */
 export function saveObservation(db, params) {
   const now = params.now instanceof Date ? params.now : new Date();
@@ -83,12 +198,45 @@ export function saveObservation(db, params) {
     ORDER BY created_at_epoch DESC LIMIT ?
   `).all(project, dedupCutoff, DEDUP_RECENT_LIMIT);
 
+  // Requested supersession targets, normalized. Declared BEFORE the dedup
+  // short-circuit because that path reports on them too.
+  // Self-reference is filtered inside the transaction, once the new id exists.
+  //
+  // D#201: the tokens that DON'T survive normalization are kept, not dropped.
+  // A caller who names an id and gets no supersession has to be told which id
+  // and why — the previous shape reported "requested 4, superseded 0" and
+  // "requested nothing" identically, so a mistyped or wrong-table id read as a
+  // clean success. `malformed-id` is the pre-query class; the DB-level classes
+  // are decided inside the transaction.
+  //
+  // D#205: `E#<n>` addresses the events table. Until this release `--supersedes` could
+  // only retire an observation, so a conclusion carried by an EVENT row had no retirement
+  // path at all and kept injecting from two faces after later measurement overturned it
+  // (the founding case: event #10524's "2.1-3.8x per call", retracted in prose while the
+  // row stayed live). D#201 made that failure loud; this makes it fixable.
+  const rawSupersedes = Array.isArray(params.supersedes) ? params.supersedes : [];
+  const { obs: requestedSupersedes, events: requestedSupersedeEvents, malformed: malformedSupersedes } =
+    splitSupersedeTokens(rawSupersedes);
+
   const dupMatch = recent.find((r) =>
     jaccardSimilarity(r.title, safeTitle) > DEDUP_JACCARD_THRESHOLD ||
     jaccardSimilarity(r.text || '', safeContent) > DEDUP_JACCARD_THRESHOLD
   );
   if (dupMatch) {
-    return { kind: 'duplicate', existingId: dupMatch.id, project, type };
+    // D#201: a dedup short-circuit swallows the requested supersession too — you
+    // write a correction, it reads as a near-duplicate of something saved in the
+    // last 5 minutes, and the rows you meant to retire stay live. Same sentence
+    // as the ineligible-id case ("requested, did not happen, no trace"), so it
+    // reports through the same channel rather than staying quiet.
+    return {
+      kind: 'duplicate', existingId: dupMatch.id, project, type,
+      supersededIds: [],
+      supersedeSkipped: [
+        ...malformedSupersedes,
+        ...requestedSupersedes.map((id) => ({ id, reason: 'duplicate-save', kind: 'obs' })),
+        ...requestedSupersedeEvents.map((id) => ({ id, reason: 'duplicate-save', kind: 'event' })),
+      ],
+    };
   }
 
   // FTS-indexed text field includes title + content + lesson + CJK bigrams,
@@ -99,13 +247,6 @@ export function saveObservation(db, params) {
   const bigramText = cjkBigrams(indexText);
   const textField = bigramText ? safeContent + ' ' + bigramText : safeContent;
 
-  // Requested supersession targets, normalized before the transaction opens.
-  // Self-reference is filtered inside, once the new id exists.
-  const requestedSupersedes = [...new Set(
-    (Array.isArray(params.supersedes) ? params.supersedes : [])
-      .map(Number).filter((n) => Number.isInteger(n) && n > 0)
-  )];
-
   // Atomic: observation row + observation_files junction + observation_vectors
   // (TF-IDF) + supersession tombstones. Vector write is best-effort — vocab may be
   // uninitialized on a fresh DB; failure must not roll back the observation.
@@ -139,6 +280,7 @@ export function saveObservation(db, params) {
     // Write-the-correction and retire-its-predecessors is one unit or neither.
     const ids = requestedSupersedes.filter((n) => n !== savedId);
     let supersededIds = [];
+    const skipped = [];
     if (ids.length > 0) {
       const ph = ids.map(() => '?').join(',');
       const eligible = db.prepare(
@@ -150,11 +292,80 @@ export function saveObservation(db, params) {
           .run(now.getTime(), savedId, ...eligible);
         supersededIds = eligible;
       }
+      // D#201: classify the difference instead of discarding it. One extra
+      // SELECT, and only when something actually failed to land — the happy
+      // path (every id eligible) skips it entirely.
+      const landed = new Set(eligible);
+      const missed = ids.filter((n) => !landed.has(n));
+      if (missed.length > 0) {
+        const ph3 = missed.map(() => '?').join(',');
+        const rows = new Map(db.prepare(
+          `SELECT id, project, superseded_at FROM observations WHERE id IN (${ph3})`
+        ).all(...missed).map((r) => [r.id, r]));
+        for (const n of missed) {
+          const row = rows.get(n);
+          // Order matters: a row can be BOTH foreign-project and already
+          // superseded, and "it isn't yours" is the more actionable of the two.
+          if (!row) skipped.push({ id: n, reason: 'no-such-observation', kind: 'obs' });
+          else if (row.project !== project) skipped.push({ id: n, reason: 'other-project', kind: 'obs' });
+          else skipped.push({ id: n, reason: 'already-superseded', kind: 'obs' });
+        }
+      }
+    }
+
+    // D#205, the events half. Same three DB-level classes, same one-extra-SELECT-only-on-
+    // failure shape, and inside the SAME transaction as the observation write for the same
+    // reason: a correction that lands while the row it overturns stays live is the state
+    // supersession exists to prevent.
+    //
+    // `superseded_at_epoch` now carries TWO meanings on this table, and nothing
+    // distinguishes them: `lib/activity.mjs promoteInsightEvents` already stamps it to mark
+    // an event PROMOTED into an observation (its idempotency gate selects on
+    // `superseded_at_epoch IS NULL`), and this writes it to mean RETIRED BY A CORRECTION.
+    // Both consequences are benign today — a retired event correctly stops being a
+    // promotion candidate, and a promoted one correctly reports `already-superseded` as a
+    // no-op — but the skip reason reads slightly wrong for a promoted row, and any future
+    // code wanting to tell the two apart will need a second column. Flagged by the v3.89.0
+    // pre-tag review; not split here because inventing a column to record a distinction
+    // nothing currently reads is the kind of speculative schema change this repo avoids.
+    //
+    // `superseded_by_id` is deliberately left NULL. That column is
+    // `INTEGER REFERENCES events(id)`, so it cannot hold the id of the OBSERVATION doing
+    // the retiring — writing `savedId` there would point at whatever event happens to
+    // share the number, which is exactly the cross-table id collision D#202 just closed
+    // (25.7% of injectable events share an id with a live observation). A missing link is
+    // recoverable; a wrong one is not.
+    let supersededEventIds = [];
+    if (requestedSupersedeEvents.length > 0) {
+      const ph = requestedSupersedeEvents.map(() => '?').join(',');
+      const eligible = db.prepare(
+        `SELECT id FROM events WHERE id IN (${ph}) AND project = ? AND superseded_at_epoch IS NULL`
+      ).all(...requestedSupersedeEvents, project).map((r) => r.id);
+      if (eligible.length > 0) {
+        const ph2 = eligible.map(() => '?').join(',');
+        db.prepare(`UPDATE events SET superseded_at_epoch = ? WHERE id IN (${ph2})`)
+          .run(now.getTime(), ...eligible);
+        supersededEventIds = eligible;
+      }
+      const landed = new Set(eligible);
+      const missed = requestedSupersedeEvents.filter((n) => !landed.has(n));
+      if (missed.length > 0) {
+        const ph3 = missed.map(() => '?').join(',');
+        const rows = new Map(db.prepare(
+          `SELECT id, project, superseded_at_epoch FROM events WHERE id IN (${ph3})`
+        ).all(...missed).map((r) => [r.id, r]));
+        for (const n of missed) {
+          const row = rows.get(n);
+          if (!row) skipped.push({ id: n, reason: 'no-such-event', kind: 'event' });
+          else if (row.project !== project) skipped.push({ id: n, reason: 'other-project', kind: 'event' });
+          else skipped.push({ id: n, reason: 'already-superseded', kind: 'event' });
+        }
+      }
     }
 
-    return { savedId, supersededIds };
+    return { savedId, supersededIds, supersededEventIds, skipped };
   });
-  const { savedId, supersededIds } = saveTx();
+  const { savedId, supersededIds, supersededEventIds, skipped } = saveTx();
 
   return {
     kind: 'saved',
@@ -164,5 +375,13 @@ export function saveObservation(db, params) {
     title: safeTitle,
     lessonCaptured: Boolean(safeLesson),
     supersededIds,
+    // D#205: kept in its OWN array rather than merged into supersededIds. The two are
+    // different tables that share an id space, so a merged list would be ambiguous at
+    // exactly the point a reader needs to know which row was retired.
+    supersededEventIds,
+    // D#201: requested-but-not-superseded, with a reason each. Malformed tokens
+    // are prepended because they were rejected before the query and so carry the
+    // caller's ORIGINAL token (which may not even be a number) rather than an id.
+    supersedeSkipped: [...malformedSupersedes, ...skipped],
   };
 }

package/mem-cli.mjs

@@ -55,7 +55,7 @@ import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { isNativeBindingError, healAndReexec } from './lib/binding-probe.mjs';
 import { CLI_PATH, CLI_INVOKE } from './cli-path.mjs';
 import { parseArgs, out, outVerbatim, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, resolvePositionalAlias, suggestUnknownFlags, OBS_TIME_FIELDS, formatObsFieldValue, obsFieldLabel, formatPendingPurgeLine } from './cli/common.mjs';
-import { saveObservation } from './lib/save-observation.mjs';
+import { saveObservation, formatSupersedeSkipped, formatSupersededNote } from './lib/save-observation.mjs';
 import { normalizeScope, insertObservationVector, applyObsUpdate } from './lib/observation-write.mjs';
 import { EXPORT_COLUMNS_SQL } from './lib/export-columns.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
@@ -80,7 +80,7 @@ const SURFACE_LABELS = {
 };
 import { aggregateMetrics, readMetrics } from './lib/metrics.mjs';
 import {
-  insertDeferred, listOpenWithOrdinal, dropDeferred,
+  insertDeferred, listOpenWithOrdinal, dropDeferred, formatDropReasonHint,
   resolveDeferredIds, closeDeferredItems,
   getDeferredByIds, formatDeferredDetail,
   searchDeferredWork, formatDeferredSearchTrailer,
@@ -896,7 +896,7 @@ function cmdSave(db, args) {
   const text = resolvePositionalAlias(positional.join(' '), flags, ['text', 'content']);
   if (text === null) return;
   if (!text.trim()) {
-    fail('[mem] Usage: claude-mem-lite save "<text>" [--type T] [--title T] [--importance N] [--project P] [--files f1,f2] [--lesson T] [--closes-deferred 1,D#42] [--supersedes 8754,8771] — content may also be passed via --text/--content "<text>"');
+    fail('[mem] Usage: claude-mem-lite save "<text>" [--type T] [--title T] [--importance N] [--project P] [--files f1,f2] [--lesson T] [--closes-deferred 1,D#42] [--supersedes 8754,E#10524] — content may also be passed via --text/--content "<text>"');
     return;
   }
 
@@ -949,16 +949,23 @@ function cmdSave(db, args) {
     }
   }
 
-  // --supersedes: comma-separated observation ids this save overturns. On save they
-  // are tombstoned (drop out of live search) + linked (superseded_by = the new id).
-  // Only same-project live rows are affected (enforced in saveObservation).
+  // --supersedes: comma-separated ids this save overturns — a bare number for an
+  // observation, `E#<n>` for an events row (D#205). Both are tombstoned (dropped from
+  // live search); only the observation half is LINKED (`superseded_by` = the new id),
+  // because `events.superseded_by_id` references events and cannot hold an observation
+  // id. Only same-project live rows are affected (enforced in saveObservation).
   let supersedesIds = null;
   if (flags.supersedes !== undefined && flags.supersedes !== false) {
     const raw = String(flags.supersedes);
-    supersedesIds = raw.split(',').map(t => t.trim()).filter(Boolean)
-      .map(t => parseInt(t, 10)).filter(n => Number.isInteger(n) && n > 0);
+    // Tokens go through UNPARSED so saveObservation's classifier — not parseInt — decides
+    // what is malformed. parseInt is lenient in the one direction that costs data: it read
+    // `1abc` as 1, so a typo (`875x` for `8754`) tombstoned an unrelated observation and
+    // printed a clean `Superseded: #1.` Worse, the token vanished before saveObservation
+    // saw it, which made the `malformed-id` class D#201 added unreachable from the CLI —
+    // the exact face whose silence motivated D#201. Number() rejects `1abc` as NaN.
+    supersedesIds = raw.split(',').map((t) => t.trim()).filter(Boolean);
     if (supersedesIds.length === 0) {
-      fail('[mem] --supersedes requires at least one positive observation id (e.g. --supersedes 8754,8771)');
+      fail('[mem] --supersedes requires at least one id: a number for an observation, or E#<n> for an event (e.g. --supersedes 8754,E#10524)');
       return;
     }
   }
@@ -984,7 +991,11 @@ function cmdSave(db, args) {
       // the deferred row has transitioned out of 'open'.
       if (r.kind === 'duplicate') return r;
       if (closesTokens) {
-        closesIds = resolveDeferredIds(db, project, closesTokens);
+        // D#195: the close verb accepts a 'dropped' row and converts it to
+        // 'done'. `defer drop` used on an item that was actually fixed was
+        // otherwise a one-way gate, permanently losing the obs link. Kept in
+        // sync with the same policy in server.mjs mem_save.
+        closesIds = resolveDeferredIds(db, project, closesTokens, { allowStatuses: ['open', 'dropped'] });
         closeDeferredItems(db, closesIds, r.id);
       }
       return r;
@@ -1000,6 +1011,10 @@ function cmdSave(db, args) {
 
   if (result.kind === 'duplicate') {
     out(`[mem] Skipped: similar to existing #${result.existingId}. Use "claude-mem-lite get ${result.existingId}" to review.`);
+    // D#201: the dedup swallowed the requested supersession too — say so here,
+    // because this branch returns before the note below is ever reached.
+    const dupSkip = formatSupersedeSkipped(result.supersedeSkipped);
+    if (dupSkip) out(`[mem] ${dupSkip}`);
     return;
   }
 
@@ -1007,14 +1022,16 @@ function cmdSave(db, args) {
   const closedNote = closesIds && closesIds.length > 0
     ? ` Closed: ${closesIds.map(i => `D#${i}`).join(', ')}.`
     : '';
-  const supersededNote = result.supersededIds && result.supersededIds.length > 0
-    ? ` Superseded: ${result.supersededIds.map(i => `#${i}`).join(', ')}.`
-    : '';
+  const supersededNote = formatSupersededNote(result);
   // G1+G2: detached backfill worker (lesson for obligated types + aliases for
   // every save) — fill-only-empty, so an agent acting on the nudge still wins.
   const enrichNote = shouldQueueSaveEnrich(result) && queueSaveEnrich(result.id)
     ? ' (background enrichment queued)' : '';
   out(`[mem] Saved #${result.id} [${result.type}] "${truncate(result.title, 80)}" (project: ${result.project})${lessonNote}${closedNote}${supersededNote}${enrichNote}${buildLessonNudge({ type: result.type, id: result.id, lessonCaptured: result.lessonCaptured, surface: 'cli' })}`);
+  // D#201: on its OWN line, after the success line. Appending it to the success
+  // string would put a warning inside a sentence that reads as "done".
+  const skipNote = formatSupersedeSkipped(result.supersedeSkipped);
+  if (skipNote) out(`[mem] ${skipNote}`);
 }
 
 // ─── cmdDefer (sub-dispatch: add | list | drop) ──────────────────────────────
@@ -1149,6 +1166,12 @@ function cmdDeferDrop(db, args) {
   if (noop.length > 0) {
     out(`[mem] No-op (not in 'open' status): ${noop.map(id => `D#${id}`).join(', ')}`);
   }
+  // D#195 (c): catch the mis-drop at the moment it happens, not months later
+  // when the ledger can no longer tell a fixed item from a rejected one.
+  if (dropped.length > 0) {
+    const hint = formatDropReasonHint(reason);
+    if (hint) out(`[mem] ${hint}`);
+  }
 }
 
 // N-1: Quality-focused stats for R-2 A/B baseline.
@@ -2540,10 +2563,19 @@ function cmdCitationStats(db, args) {
      LIMIT 20
   `).all();
 
+  // D#179/D#198, second half: the sibling `demoted` caption below was re-worded when the
+  // decay loop stopped writing `importance`, and this one was not — the same "the copy I
+  // fixed was not the only copy" shape the batch's own sweeps exist to prevent. Gating on
+  // `importance >= 3` made the section structurally empty for anything the loop produces:
+  // a row cited in ten sessions now has cited_count = 10 and whatever importance it was
+  // saved with, so the section degenerated into "rows that were already at 3" under a
+  // caption reading "promoted". The discriminator is now the pair the promote branch
+  // actually writes (`cited_count + 1`, `uncited_streak = 0`); `importance` is still
+  // SELECTed and printed, so a reader can see it is unrelated.
   const promoted = db.prepare(`
     SELECT id, project, type, title, importance, cited_count
       FROM observations
-     WHERE importance >= 3 AND cited_count >= 1
+     WHERE cited_count >= 1 AND COALESCE(uncited_streak, 0) = 0
        AND ${liveObsFilterSql('')}
   ORDER BY cited_count DESC
      LIMIT 10
@@ -2665,19 +2697,23 @@ function cmdCitationStats(db, args) {
     }
   }
   out('');
-  out('Active decay queue (uncited_streak >= 2, next miss → demote):');
+  out('Active decay queue (uncited_streak >= 2, next miss → rollover):');
   if (decayQueue.length === 0) out('  (none)');
   for (const r of decayQueue) {
     out(`  #${r.id} [${r.type}] ${(r.title || '').slice(0, 60)}   imp=${r.importance} streak=${r.uncited_streak}`);
   }
   out('');
-  out('Recently promoted (importance=3, cited_count >= 1):');
+  out('Recently cited (cited_count >= 1, streak reset; importance unaffected):');
   if (promoted.length === 0) out('  (none)');
   for (const r of promoted) {
     out(`  #${r.id} [${r.type}] ${(r.title || '').slice(0, 60)}   cited ${r.cited_count}x`);
   }
   out('');
-  out(`Recently demoted (last ${days}d, importance ↓):`);
+  // D#179/D#198: demoted_at now stamps the UNCITED-STREAK ROLLOVER, which no
+  // longer lowers importance. The old label ("importance ↓") would describe a
+  // write that stopped happening while the column beside it kept printing the
+  // row's unchanged value — a caption contradicting its own table.
+  out(`Recently rolled over (last ${days}d, uncited streak reset; importance unaffected):`);
   if (demoted.length === 0) out('  (none)');
   for (const r of demoted) {
     const ago = Math.round((Date.now() - r.demoted_at) / DAY_MS);

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.87.0",
+  "version": "3.89.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/scoring-sql.mjs

@@ -185,11 +185,21 @@ export function notLowSignalTitleClause(alias = 'o') {
 //
 // Closes the citation-decay → ranking loop. The Stop hook citation-decay
 // already maintains cited_count (Promote on cite) and uncited_streak (bump on
-// uncited; reset on cite or demote-at-3). Before A1, both columns affected
+// uncited; reset on cite or rollover-at-3). Before A1, both columns affected
 // only the importance ±1 dial — through `(0.5 + 0.5·importance)` that's a
 // ≤2× swing and saturates fast. This factor lets ranking respond directly to
 // observed agent behavior on the obs itself.
 //
+// D#179/D#198 made this factor the ONLY thing citation-decay feeds: that loop
+// no longer writes `importance` at all. The reason is that importance is not a
+// ranking dial — every injection surface gates candidacy on it, so moving it
+// changed WHO IS IN the pool rather than where they ranked. This clause is the
+// right home for the signal precisely because it is bounded and pure-ranking:
+// a mis-read citation costs at most a 3.0× / 0.4× rank shift and can never
+// evict a row. (A second, independent citation → importance path still exists
+// via bumpCitationAccess → access_count → the `boost` maintain op; see obs
+// #10911. It is out of this clause's scope and is NOT closed.)
+//
 // Formula: clamp(0.4, 3.0, 1 + 0.2·cited_count − 0.25·uncited_streak)
 // Distribution:
 //   cited=0, streak=0  → 1.0  (fresh obs, neutral)

package/scripts/pre-tool-recall.js

@@ -8,7 +8,7 @@ import { existsSync, readFileSync, mkdirSync } from 'fs';
 import { basename, join } from 'path';
 import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
 import { atomicWriteFileSync } from '../lib/atomic-write.mjs';
-import { injectedIdsFileName, injectedIdKey } from '../lib/injected-ids.mjs';
+import { injectedIdsFileName, injectedIdKey, EVENT_ID_PREFIX } from '../lib/injected-ids.mjs';
 import { liveObsFilterSql } from '../lib/inject-search-core.mjs';
 import { buildNotLowSignalSql } from '../lib/low-signal-patterns.mjs';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
@@ -660,17 +660,36 @@ try {
     if (fileIntelLine) lines.push(neutralizeContextDelimiters(fileIntelLine));
     if (hasLessons) {
       lines.push(`[mem] Lessons for ${fname}:`);
+      // D#202: this block merges TWO TABLES and rendered both with a bare `#NN`.
+      // lib/events-injection.mjs already established the `E#` prefix for exactly
+      // this reason, and its header even enumerates the extractors the prefix
+      // protects — FYI, memory-context, error-recall. It does not name THIS face,
+      // which is the one that was breaking the invariant.
+      //
+      // Measured on the live metrics log (4227 `pretool_recall` firings,
+      // 2026-07-18 -> 2026-09-02): 44.9% of the rows injected here are
+      // event-sourced and 40.2% of firings inject events only. Two costs:
+      //   * a reader cannot tell which table to follow an id into — a
+      //     `--supersedes` or `mem_get` on one fails for no visible reason;
+      //   * load-bearing: extractInjectedFromPreToolUse reads these ids into the
+      //     citation-decay DENOMINATOR, and applyCitationDecay resolves them
+      //     against `observations` alone, so an event id colliding with a live
+      //     SAME-PROJECT observation streaked or promoted an unrelated memory.
+      //     198 of 5476 injectable events (3.6%) sit in that position.
+      // The `E#` prefix closes the second by construction: INJECTED_ROW_RE
+      // anchors `#` after at most six spaces, so `E#` cannot match it.
       for (const r of allRows) {
+        const idTag = `${r.src === 'evt' ? EVENT_ID_PREFIX : '#'}${r.id}`;
         if (r.lesson_learned) {
           const lesson = r.lesson_learned.length > LESSON_MAX
             ? r.lesson_learned.slice(0, LESSON_MAX - 3) + '...'
             : r.lesson_learned;
-          lines.push(`  #${r.id} [${r.type}] ${neutralizeContextDelimiters(lesson)}`);
+          lines.push(`  ${idTag} [${r.type}] ${neutralizeContextDelimiters(lesson)}`);
         } else {
           const title = (r.title || '').length > LESSON_MAX
             ? r.title.slice(0, LESSON_MAX - 3) + '...'
             : (r.title || '');
-          lines.push(`  #${r.id} [${r.type}] ${neutralizeContextDelimiters(title)}`);
+          lines.push(`  ${idTag} [${r.type}] ${neutralizeContextDelimiters(title)}`);
         }
       }
       // v2.98 salience: Edit/Write is the action point — close the block with an
@@ -747,9 +766,16 @@ try {
     };
     writeCooldown(cooldownPath, cooldown, isSessionScoped);
     // A3 (v2.83): merge our newly-emitted IDs into the cross-hook injected
-    // file so the next UPS prompt skips them too. Always write, even on
-    // empty allRows, so the file's ts stays fresh for the no-op case where
-    // we'd otherwise drift outside the dedup window.
+    // file so the next UPS prompt skips them too.
+    //
+    // This comment used to say "Always write, even on empty allRows, so the file's ts
+    // stays fresh". It does not: `mergeCrossHookInjected` returns on line 268 when
+    // `newIds` is empty, so a firing that emits nothing leaves the timestamp where it
+    // was and the marker can age out of the dedup window. Corrected rather than
+    // implemented — refreshing `ts` on an empty firing would EXTEND suppression on the
+    // strength of an injection that did not happen, which is the opposite of what the
+    // window is for. The practical consequence is only that the trigger condition for
+    // D#193 is "PreToolUse emitted at least one row in the window", not "always".
     // D#188: namespaced on write too — otherwise a bare event id here would keep
     // blocking the same-numbered observation on the next UPS prompt. (An earlier
     // version of this comment also claimed it leaked into hook.mjs's