claude-mem-lite 3.86.0 → 3.88.0

package/lib/deferred-work.mjs

@@ -119,6 +119,55 @@ export function dropDeferred(db, id, reason) {
   return { changed: r.changes };
 }
 
+/**
+ * Reasons that mean "this item was FIXED", for which `defer drop` is the wrong
+ * verb — dropping loses the closed_by_obs_id link that `save --closes-deferred`
+ * would have written, and leaves the row indistinguishable from a genuinely
+ * rejected one (D#195; v3.86.0 dropped six fixed items this way).
+ *
+ * Deliberately a POSITIVE pattern for the fixed-shape, not a stop-list of
+ * rejection wordings: the set of ways to say "no longer relevant" is open-ended,
+ * the set of ways to say "done" is small. Advisory only — the drop still
+ * succeeds, so a false positive costs one line of output.
+ */
+// `closed` and `landed` are here because of the six real v3.86.0 mis-drops this
+// hint exists to prevent: their reason was "closed this round; fix + mutation-
+// verified binding test landed", which an earlier draft anchored on `fixed` and
+// `closed by` and therefore MISSED — the motivating case fell through its own
+// predicate. Bare `fix` is deliberately NOT here: "waiting for an upstream fix"
+// is a legitimate rejection and carries no veto word in English.
+const DROP_REASON_FIXED_RE = /\b(fixed|implemented|shipped|resolved|done|closed|landed)\b|修复|已实现|已完成|完成了|已发布|已解决/i;
+
+/**
+ * Negative-sense veto, applied to the WHOLE reason before the positive pattern.
+ *
+ * A lookbehind cannot do this job: the sense-carrying word is not adjacent to the
+ * keyword. "等待上游修复" (waiting for an upstream fix) puts 游 immediately before
+ * 修复, so `(?<![待未需])修复` still fires on it — measured, which is why the
+ * predicate is two-stage rather than one clever pattern. Suppression is the safe
+ * direction here: a missed hint costs nothing, a wrong hint trains the reader to
+ * ignore the line.
+ */
+// `wontfix` is spelled with no boundary after `wont`, so a plain `won'?t\b` misses the
+// single most common English way of writing this rejection and the hint then fires on
+// "resolved as wontfix" — the positive arm's `resolved` winning over a veto that never
+// ran. Matched explicitly rather than by loosening the boundary, which would also admit
+// `wonton`. (pre-tag review v3.88.0, correctness N4)
+const DROP_REASON_NOT_YET_RE = /\bwon'?tfix\b|\b(not|won'?t|cannot|can'?t|unable|pending|todo|blocked|waiting|obsolete|superseded|duplicate|irrelevant|refuted)\b|待|未|尚|需|无法|暂不|过时|重复|取代/i;
+
+/**
+ * @param {string} reason The drop reason about to be recorded.
+ * @returns {string|null} Advisory hint, or null when the reason does not look
+ *          like a completion.
+ */
+export function formatDropReasonHint(reason) {
+  if (typeof reason !== 'string') return null;
+  if (DROP_REASON_NOT_YET_RE.test(reason)) return null;
+  if (!DROP_REASON_FIXED_RE.test(reason)) return null;
+  return '⚠ that reason reads like the item was FIXED — prefer `save --closes-deferred D#<id>`, '
+    + 'which records status=done plus the closing observation id. `drop` records a rejection.';
+}
+
 /**
  * Fetch full deferred_work rows by raw id — ANY status, input order preserved,
  * missing ids omitted. This is the read half of the D# surface: `defer list`
@@ -161,6 +210,11 @@ export function formatDeferredDetail(row) {
   if (row.created_at_epoch) lines.push(`created: ${new Date(row.created_at_epoch).toISOString()}`);
   if (row.status === 'dropped' && row.drop_reason) lines.push(`drop_reason: ${row.drop_reason}`);
   if (row.status === 'done' && row.closed_by_obs_id) lines.push(`closed_by: #${row.closed_by_obs_id}`);
+  // D#195: a row re-closed out of 'dropped' keeps its drop_reason. Render it under
+  // a distinct label rather than dropping it from the view — the mis-drop is the
+  // part a later reader needs, and a `drop_reason:` line on a done row would read
+  // as a contradiction.
+  if (row.status === 'done' && row.drop_reason) lines.push(`previously_dropped: ${row.drop_reason}`);
   return lines.join('\n');
 }
 
@@ -258,18 +312,31 @@ export function formatDeferredSearchTrailer(rows, invokeHint) {
 
 /**
  * Resolve mixed ordinal (int) + raw-id ("D#<n>") tokens to real deferred_work
- * ids, validated against caller project + status='open'.
+ * ids, validated against caller project + an allowed status set.
  *
  * - bare integer N → ordinal-within-project (uses same ROW_NUMBER as listOpenWithOrdinal)
- * - "D#<n>" string → raw deferred_work.id; must belong to caller project AND be open
+ * - "D#<n>" string → raw deferred_work.id; must belong to caller project AND
+ *   carry an allowed status
+ *
+ * `allowStatuses` defaults to open-only, which is the DROP verb's policy and the
+ * historical behaviour of every caller. The CLOSE verb (`save --closes-deferred`)
+ * passes `['open', 'dropped']` per D#195: dropping an item that was actually
+ * fixed used to be a one-way gate, permanently losing the closed_by_obs_id link.
+ * 'done' is never allowed under either policy — re-closing would overwrite an
+ * existing obs link with a different one.
+ *
+ * Ordinals stay open-only under every policy: the ROW_NUMBER that defines them
+ * is computed over open rows, so a dropped row simply has no ordinal to name.
+ * Reaching one requires the explicit `D#<n>` form.
  *
  * @param {Database} db
  * @param {string} project Caller project (FK guard)
  * @param {Array<number|string>} tokens Mixed input
+ * @param {{allowStatuses?: string[]}} [opts]
  * @returns {number[]} Real deferred_work ids in input order
  * @throws {Error} On unresolvable input — error message names the offending token
  */
-export function resolveDeferredIds(db, project, tokens) {
+export function resolveDeferredIds(db, project, tokens, { allowStatuses = ['open'] } = {}) {
   if (!Array.isArray(tokens)) throw new Error('tokens must be an array');
   // Pre-load open list once for ordinal resolution (ROW_NUMBER snapshot stable
   // within this call so [1, 2] resolves consistently).
@@ -300,10 +367,11 @@ export function resolveDeferredIds(db, project, tokens) {
       if (row.project !== project) {
         throw new Error(`D#${id} belongs to project "${row.project}", not "${project}"`);
       }
-      if (row.status !== 'open') {
+      if (!allowStatuses.includes(row.status)) {
         // Verb-neutral: resolveDeferredIds is shared by close (save --closes-deferred)
         // AND drop (mem_defer_drop), so "cannot close" mis-described the drop path.
-        throw new Error(`D#${id} status is "${row.status}" — only 'open' items can be closed or dropped`);
+        const allowed = allowStatuses.map(s => `'${s}'`).join(' or ');
+        throw new Error(`D#${id} status is "${row.status}" — only ${allowed} items are accepted here`);
       }
     } else {
       throw new Error(`invalid token type ${typeof t} — expected D#N or integer ordinal`);
@@ -327,7 +395,7 @@ export function resolveDeferredIds(db, project, tokens) {
  * @param {Database} db
  * @param {number[]} ids Already-resolved real ids (use resolveDeferredIds first)
  * @param {number} closingObsId observations.id that proves closure
- * @throws {Error} If any id is not currently open (lookup-based safety net)
+ * @throws {Error} If any id is neither 'open' nor 'dropped' (lookup-based safety net)
  */
 export function closeDeferredItems(db, ids, closingObsId) {
   if (!Array.isArray(ids) || ids.length === 0) return;
@@ -337,17 +405,22 @@ export function closeDeferredItems(db, ids, closingObsId) {
   // Defense-in-depth: even if caller already validated via resolveDeferredIds,
   // re-check status here (caller may have done resolution earlier in the same
   // transaction without holding a lock).
+  //
+  // D#195: 'dropped' is closable. drop_reason is intentionally NOT cleared — the
+  // row's history is what makes a mis-drop auditable, and formatDeferredDetail
+  // renders it as `previously_dropped:` once the status is 'done'. 'done' stays
+  // excluded so a second close cannot overwrite an existing closed_by_obs_id.
   const stmt = db.prepare(`
     UPDATE deferred_work
     SET status='done', closed_at_epoch=?, closed_by_obs_id=?
-    WHERE id=? AND status='open'
+    WHERE id=? AND status IN ('open', 'dropped')
   `);
   const now = Date.now();
   const tx = db.transaction((idList) => {
     for (const id of idList) {
       const r = stmt.run(now, closingObsId, id);
       if (r.changes !== 1) {
-        throw new Error(`closeDeferredItems: id ${id} was not in 'open' status (changes=${r.changes})`);
+        throw new Error(`closeDeferredItems: id ${id} was not in a closable status ('open' or 'dropped') (changes=${r.changes})`);
       }
     }
   });

package/lib/events-injection.mjs

@@ -20,9 +20,20 @@
 // row is never mis-attributed to an observation id (which would let citation decay
 // mutate an unrelated observation sharing that id). Events carry no citation columns,
 // so they inject as reference-only — reachability, not decay bookkeeping.
+//
+// D#202: that paragraph was true of the faces it names and FALSE of the one it does
+// not. `scripts/pre-tool-recall.js` renders its own merged obs+event rows and used a
+// bare `#` for both, so nearly half of that channel's injected rows (44.9%, measured
+// over 4227 firings) were event ids entering the observation decay denominator —
+// exactly the mis-attribution this prefix exists to prevent. The invariant was stated
+// here while the face that broke it lived elsewhere and was not enumerated. The prefix
+// is now a shared constant (lib/injected-ids.mjs, a leaf so the hot PreToolUse path
+// need not pull this file's search-core chain) and
+// tests/pretool-event-id-namespace.test.mjs sweeps both renderers.
 
 import { searchEventsFts } from './search-core.mjs';
 import { neutralizeContextDelimiters } from '../format-utils.mjs';
+import { EVENT_ID_PREFIX } from './injected-ids.mjs';
 
 const DEFAULT_LIMIT = 3;
 const DEFAULT_MIN_IMPORTANCE = 2;
@@ -98,7 +109,7 @@ export function renderInjectableEvent(row) {
   // hook-llm.mjs behind `if (EVENT_TYPE_SET.has(summary.type))`), so it carries no
   // injection markers and is intentionally NOT defanged — mirrors the un-defanged
   // `[type]` for observations. If an unvalidated event writer is ever added, defang it.
-  const head = `E#${row.id} [${row.type}] ${title}`;
+  const head = `${EVENT_ID_PREFIX}${row.id} [${row.type}] ${title}`;
   if (row.lesson_learned) {
     const lesson = neutralizeContextDelimiters(row.lesson_learned.trim().slice(0, LESSON_MAX));
     if (lesson) return `${head} — ${lesson}`;

package/lib/injected-ids.mjs

@@ -53,10 +53,16 @@ export function injectedIdsFileName(project, sessionId) {
  * and feeds that single value to BOTH `crossHookInjectedFile(project, sessionId)` and
  * the events `SELECT ... WHERE project = ?`. So the scoping that matters is the
  * SESSION's project. The draft instead scoped by the injected observation's own
- * `project` column — a different question, since the `ups`/`fyi` faces do inject
- * cross-project rows — and reported 9 in 9 (15.5%), understating it. The pre-tag claims
+ * `project` column and reported 9 in 9 (15.5%), understating it. The pre-tag claims
  * review caught the population, having reconstructed it independently at 12 in 10.
  *
+ * That is not a rounding difference, and the number that proves it is worth carrying:
+ * **134 of 216 injected `ups` ids (62.0%) belong to a project OTHER than the session
+ * they were injected into** (2026-09-01T20:36Z; the review measured 128/210 = 61% an
+ * hour earlier). The `ups` face has a cross-project leg and it dominates, so "the
+ * observation's project" and "the session's project" select genuinely different
+ * populations — and only the latter is one the dedup mechanism ever asks about.
+ *
  * The predicate, stated here because no harness is committed for it: seen-set per
  * session = the shipped `extractInjectedBySurface(path).ups`; injectable events =
  * `importance >= 2 AND superseded_at_epoch IS NULL AND file_paths NOT IN (NULL,'[]')`;
@@ -89,6 +95,23 @@ export function injectedIdKey(id, src = 'obs') {
   return src === 'evt' ? `E${id}` : String(id);
 }
 
+/**
+ * DISPLAY prefix for an event id rendered into an injected line, as opposed to
+ * `injectedIdKey` above, which namespaces the same id inside the marker FILE.
+ * Two forms of one convention: the marker key is `E<id>` (no `#`, it is not
+ * citable text), the rendered token is `E#<id>` (the `#` is what makes an id
+ * look like an id to a reader).
+ *
+ * It lives in this leaf module — rather than beside either renderer — because
+ * D#202 was exactly the two renderers not agreeing. lib/events-injection.mjs
+ * had the `E#` convention and a header explaining it; scripts/pre-tool-recall.js
+ * rendered its own merged obs+event rows with a bare `#`, putting 44.9% of that
+ * channel's ids into the observation citation-decay denominator. Importing from
+ * here also keeps the hot PreToolUse path off events-injection.mjs's
+ * search-core.mjs dependency chain.
+ */
+export const EVENT_ID_PREFIX = 'E#';
+
 /**
  * Runtime-dir FILE NAME for the SessionStart Key Context marker: the obs ids
  * ACTUALLY rendered into the <claude-mem-context> File Lessons / Key Context

package/lib/maintain-core.mjs

@@ -265,8 +265,10 @@ export function recoverOrphanedChildren(db, { projectFilter = '', baseParams = [
   `).run(...baseParams).changes;
 }
 
-// Heal lesson-bearing rows that citation-decay buried at importance 0 under the old
-// IMPORTANCE_FLOOR=0 (fixed in citation-tracker.mjs → floor 1). All passive injection
+// Heal lesson-bearing rows that citation-decay buried at importance 0 back when its floor
+// was 0. That loop was later given a floor of 1, and as of D#179/D#198 it does not write
+// `importance` on any branch at all — so this op no longer has an active producer and only
+// drains the historical backlog. Keep it: nothing else lifts a stranded 0. All passive injection
 // surfaces exclude importance 0 (pre-tool-recall >=2, user-prompt-search >=1, memory-context
 // >=1), so a lesson demoted there is invisible AND — being injection_count>0 by construction
 // — sits in no GC queue either (decayAndMarkIdle only marks injection_count=0 rows): stranded

package/lib/save-observation.mjs

@@ -18,6 +18,31 @@ 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',
+  'other-project': 'belongs to a different project',
+  'already-superseded': 'already superseded (no-op)',
+  'duplicate-save': 'the save deduped, so nothing was superseded',
+};
+
+/**
+ * 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.
+ *
+ * @param {Array<{id: any, reason: string}>} [skipped]
+ * @returns {string|null} null when nothing was skipped
+ */
+export function formatSupersedeSkipped(skipped) {
+  if (!Array.isArray(skipped) || skipped.length === 0) return null;
+  const parts = skipped.map(({ id, reason }) =>
+    `#${id} (${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 +57,18 @@ 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` (what was actually tombstoned) and
+ * `supersedeSkipped` (requested but NOT tombstoned, each with a `reason`:
+ * `malformed-id` | `no-such-observation` | `other-project` |
+ * `already-superseded` | `duplicate-save`). Callers MUST surface a non-empty
+ * `supersedeSkipped` — that is the whole point of D#201; dropping it puts the
+ * silent failure back.
+ *
+ * @returns {{ kind: 'duplicate', existingId: number, project: string, type: string,
+ *             supersededIds: number[], supersedeSkipped: Array<{id: any, reason: string}> }
+ *          | { kind: 'saved', id: number, type: string, project: string, title: string,
+ *              lessonCaptured: boolean, supersededIds: number[],
+ *              supersedeSkipped: Array<{id: any, reason: string}> }}
  */
 export function saveObservation(db, params) {
   const now = params.now instanceof Date ? params.now : new Date();
@@ -83,12 +118,42 @@ 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.
+  const rawSupersedes = Array.isArray(params.supersedes) ? params.supersedes : [];
+  const requestedSupersedes = [...new Set(
+    rawSupersedes.map(Number).filter((n) => Number.isInteger(n) && n > 0)
+  )];
+  const malformedSupersedes = rawSupersedes
+    .filter((t) => { const n = Number(t); return !(Number.isInteger(n) && n > 0); })
+    .map((t) => ({ id: t, reason: 'malformed-id' }));
+
   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' })),
+      ],
+    };
   }
 
   // FTS-indexed text field includes title + content + lesson + CJK bigrams,
@@ -99,13 +164,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 +197,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 +209,30 @@ 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' });
+          else if (row.project !== project) skipped.push({ id: n, reason: 'other-project' });
+          else skipped.push({ id: n, reason: 'already-superseded' });
+        }
+      }
     }
 
-    return { savedId, supersededIds };
+    return { savedId, supersededIds, skipped };
   });
-  const { savedId, supersededIds } = saveTx();
+  const { savedId, supersededIds, skipped } = saveTx();
 
   return {
     kind: 'saved',
@@ -164,5 +242,9 @@ export function saveObservation(db, params) {
     title: safeTitle,
     lessonCaptured: Boolean(safeLesson),
     supersededIds,
+    // 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 } 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,
@@ -955,8 +955,13 @@ function cmdSave(db, args) {
   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)');
       return;
@@ -984,7 +989,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 +1009,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;
   }
 
@@ -1015,6 +1028,10 @@ function cmdSave(db, args) {
   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.86.0",
+  "version": "3.88.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.86.0",
+      "version": "3.88.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.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).",
   "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