claude-mem-lite 3.89.0 → 3.90.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.89.0",
+      "version": "3.90.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.89.0",
+  "version": "3.90.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/hook-memory.mjs

@@ -247,7 +247,28 @@ function hasFilePaths(filesModified) {
  * @param {number[]} excludeIds Observation IDs already in Key Context
  * @returns {object[]} Top memories (max 3) with {id, type, title, lesson_learned}
  */
-export function searchRelevantMemories(db, userPrompt, project, excludeIds = []) {
+/**
+ * @param {object} [opts]
+ * @param {boolean} [opts.counterfactual] — this call is a MEASUREMENT, not a delivery.
+ *   Nothing it returns is shown to the model, so it must leave no trace: no
+ *   `injection_count` / `last_injected_at` bump, and no `inject` metric row.
+ *
+ *   Added for `lib/patha-exclude-meter.mjs`'s arm B (D#214). The first version of that
+ *   ruler handed this function the live writable handle, and the pre-tag review
+ *   reproduced both halves of the damage: rows that were never shown to anyone reached
+ *   `injection_count = 1` — which feeds `noisePenaltyClause`, `demotePinned`'s
+ *   `injection_count >= N AND cited_count = 0` predicate, and the `injection_count = 0`
+ *   GC-eligibility gate — and the `inject` meter counted two calls per prompt, on
+ *   exactly the installs where the D#214 corpus is gathered. CLAUDE.md already carried
+ *   this rule for `rerank-pool-replay` ("the handle must reject a write … a writable
+ *   handle would move the very noise signal being measured"); the new ruler quoted it
+ *   and then broke it.
+ *
+ *   A read-only handle would also work; a flag is used instead because the caller needs
+ *   BOTH arms to see one store state, which is achieved by ordering (arm B first, and
+ *   it writes nothing) rather than by isolation.
+ */
+export function searchRelevantMemories(db, userPrompt, project, excludeIds = [], { counterfactual = false } = {}) {
   // Min-length guard is English-centric: 5 chars ≈ one short English word. A CJK
   // query is meaningful at 2 chars (状态/架构) and most real Chinese queries are
   // 2-4 chars (状态管理, 召回率, 熔断降级) — the bare `.length < 5` silently
@@ -271,6 +292,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
   const _t0 = Date.now();
   let _candidates = 0, _aboveThreshold = 0, _returned = 0, _orFired = false;
   const _emit = () => {
+    if (counterfactual) return;
     try {
       recordMetric(DB_DIR, {
         event: 'inject',
@@ -472,12 +494,16 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     //                     denominator is citation_surface_log, not this column.
     // Per-row try/catch for FTS trigger safety (project_non_obvious.md).
     const result = coverageFiltered.slice(0, MAX_MEMORY_INJECTIONS);
-    const now = Date.now();
-    const bumpStmt = db.prepare(
-      'UPDATE observations SET injection_count = COALESCE(injection_count, 0) + 1, last_injected_at = ? WHERE id = ?'
-    );
-    for (const r of result) {
-      try { bumpStmt.run(now, r.id); } catch {}
+    // `counterfactual` skips the bump entirely rather than reverting it: these rows were
+    // never shown to anyone, and `injection_count` is read by three ranking/GC paths.
+    if (!counterfactual) {
+      const now = Date.now();
+      const bumpStmt = db.prepare(
+        'UPDATE observations SET injection_count = COALESCE(injection_count, 0) + 1, last_injected_at = ? WHERE id = ?'
+      );
+      for (const r of result) {
+        try { bumpStmt.run(now, r.id); } catch {}
+      }
     }
 
     _returned = result.length;

package/hook.mjs

@@ -84,6 +84,7 @@ import { recordSkillAdoption, gcOldShadowShards } from './registry-recommend.mjs
 import { gcOldMetricShards, recordMetric } from './lib/metrics.mjs';
 import { detectMemOverride } from './lib/mem-override.mjs';
 import { injectedIdsFileName, keyContextIdsFileName } from './lib/injected-ids.mjs';
+import { pathAMeterEnabled, coerceMarkerIds, recordPathAExclude } from './lib/patha-exclude-meter.mjs';
 import { recordKeyContextInjection, touchKeyContextMarker } from './lib/keyctx-marker.mjs';
 import { liveObsFilterSql } from './lib/inject-search-core.mjs';
 import { selectErrorRecall } from './lib/error-recall-core.mjs';
@@ -2214,9 +2215,12 @@ async function handleUserPrompt() {
           // from the pool and sometimes just lost (`rerank-pool-replay`: 6587 of 11289
           // prompts already inject nothing) and the `ups` cite-rate is 8.1%.
           //
-          // The ruler that would settle it does not exist yet: reconstructing per-prompt
-          // exclude sets needs the marker file, which rotates after DEDUP_STALE_MS and is
-          // never persisted. Tracked as a re-filed D#193 naming that as the prerequisite.
+          // The ruler that settles it is now BUILT and sits at the bottom of this same
+          // function: `lib/patha-exclude-meter.mjs`, off unless CLAUDE_MEM_METRICS=1. It
+          // does not persist the marker for an offline replay — reconstructing per-prompt
+          // exclude sets that way needs a file that rotates after DEDUP_STALE_MS, and the
+          // replay would then run against a drifted database. Both arms run at this read
+          // instead. What is still missing is elapsed time, not a method. D#213.
           // tests/pathA-exclude-inert.test.mjs pins this state so a silent flip goes red.
           for (const id of ids) { keyContextIds.push(id); pathAInjectedIds.push(id); }
         }
@@ -2238,6 +2242,42 @@ async function handleUserPrompt() {
       // until then this stays experimental and off.
       const taskImperativeOn = process.env.CLAUDE_MEM_TASK_IMPERATIVE === 'on'
         || process.env.CLAUDE_MEM_TASK_IMPERATIVE === '1';
+      // ── D#214 arm B (counterfactual), computed BEFORE the delivered arm ─────────
+      // Ordering is the whole correctness argument, so it is stated where the order is:
+      // arm A's search legitimately bumps `injection_count` on every row it delivers,
+      // and that column feeds `noisePenaltyClause`. Running the counterfactual AFTER it
+      // — as the first version did — lets arm A push a row across the >=4 noise gate and
+      // then attributes the resulting difference to the repair. The pre-tag review
+      // reproduced that: a marker id for a row the query never matches, where the honest
+      // answer is `suppressed 0 / refilled 0`, reported `refilled: 1, setChanged: true`.
+      //
+      // So arm B runs first, on the same handle, with `counterfactual: true` — it writes
+      // nothing and emits no `inject` metric row, so arm A afterwards sees exactly the
+      // state arm B saw. Both arms, one state, and neither one perturbs the other.
+      //
+      // Arm B also carries its OWN imperative pick. Reusing arm A's put a pick the
+      // repaired system would not have made into arm B's exclude, so on any prompt where
+      // the pick changed, the delta described a system that does not exist.
+      const meterCoerced = (pathAMeterEnabled() && pathAInjectedIds.length > 0)
+        ? [...coerceMarkerIds(pathAInjectedIds)]
+        : null;
+      let meterArmB = null;
+      if (meterCoerced) {
+        try {
+          const pickB = taskImperativeOn
+            ? selectImperativeLesson(db, promptText, project, [...pathAInjectedIds, ...meterCoerced])
+            : null;
+          const excludeB = pickB ? [...keyContextIds, pickB.id] : keyContextIds;
+          meterArmB = {
+            rows: searchRelevantMemories(db, promptText, project, [...excludeB, ...meterCoerced], { counterfactual: true }),
+            pick: pickB ? pickB.id : null,
+          };
+        } catch (e) {
+          debugCatch(e, 'patha-exclude-meter-armB');
+          meterArmB = { error: String(e?.message || 'unknown') };
+        }
+      }
+
       // Exclude only ids path-A (user-prompt-search.js) already injected — NOT the
       // SessionStart Key Context set, which overlaps the high-value lesson pool and
       // would suppress the pick. The chosen id is excluded from the <memory-context>
@@ -2282,6 +2322,27 @@ async function handleUserPrompt() {
         const imperativeLine = formatTaskImperative(imperativePick.lesson_learned, imperativePick.id);
         if (imperativeLine) process.stdout.write(imperativeLine + '\n');
       }
+
+      // D#214's ruler, second half: arm B was computed above, before anything was
+      // delivered; this only shapes the row and appends it. Kept after every
+      // `process.stdout.write` so the metric append is never in front of the injection,
+      // and so a throw here cannot corrupt what was already emitted.
+      //
+      // `meterCoerced` being non-null is the gate — it is null unless
+      // CLAUDE_MEM_METRICS=1 AND the marker carried ids, which is what keeps both the
+      // counterfactual search and the second lesson selection off a stock install.
+      try {
+        if (meterCoerced) {
+          recordPathAExclude(join(RUNTIME_DIR, '..'), {
+            markerIds: pathAInjectedIds,
+            emitted: memories,
+            after: meterArmB,
+            imperativeArm: taskImperativeOn ? 'on' : 'off',
+            imperativeBefore: imperativePick ? imperativePick.id : null,
+            imperativeAfter: meterArmB ? (meterArmB.pick ?? null) : null,
+          });
+        }
+      } catch (e) { debugCatch(e, 'patha-exclude-meter'); }
     } catch (e) { debugCatch(e, 'handleUserPrompt-memory'); }
   } finally {
     db.close();

package/lib/injected-ids.mjs

@@ -80,7 +80,10 @@ export function injectedIdsFileName(project, sessionId) {
  * SQLite. Measured: excluding `1` returns nothing, excluding `'1'` returns the row.
  * The pre-tag correctness review found this. What it exposes is a real and separate
  * defect — that exclude list is inert for every id the marker holds as a string,
- * observations included — which is D#193, not this one.
+ * observations included — which is D#213 (re-filed twice from D#193, because the first
+ * two versions measured the marker's WRITER instead of its reader and published 18.0%
+ * for the mirror population; the corrected upper bound is 9.0%), not this one. Its ruler
+ * is lib/patha-exclude-meter.mjs.
  *
  * Legacy in-flight files (bare ids that were a mix of both tables) keep their old
  * meaning for at most DEDUP_STALE_MS and then rotate; there is deliberately no

package/lib/patha-exclude-meter.mjs

@@ -0,0 +1,274 @@
+// lib/patha-exclude-meter.mjs — the ruler D#213 named as its only blocker.
+//
+// D#213 (which replaced D#212, which replaced D#193) is not open because the mechanism
+// is unclear. The mechanism is settled by reading: `mergeCrossHookInjected` `.map(String)`s
+// the whole marker union, `hook.mjs handleUserPrompt` pushes those ids into
+// `pathAInjectedIds` as they arrive, and both consumers test `new Set(excludeIds).has(r.id)`
+// against a NUMBER out of SQLite — so from the first PreToolUse emission in the window the
+// exclude suppresses nothing. It is open because nobody can price the repair:
+//
+//   "reconstructing per-prompt exclude sets needs the marker file, which rotates after
+//    DEDUP_STALE_MS and is never persisted"
+//
+// THIS MODULE DOES NOT SOLVE THAT BY PERSISTING THE MARKER. Recording `{project, session,
+// ids, ts}` at write time — the route the ledger leaned toward — buys a corpus that still
+// has to be replayed later, against a database that has drifted, by a harness that has to
+// re-derive which rows the search would have returned. This project has a standing rule
+// about exactly that shape ("never diff two runs taken at different times"), and three
+// separate rulers here carry a warning earned by breaking it.
+//
+// So the measurement is taken WHERE AND WHEN THE READ HAPPENS, both arms in one process
+// against one database state microseconds apart:
+//
+//   arm A (shipped)  — the exclude as it arrives: inert against every string id.
+//   arm B (repaired) — the same call with the ids coerced to numbers.
+//
+// **ORDER AND SIDE EFFECTS ARE PART OF THE CONTRACT, and the caller owns both.** Arm B
+// must run FIRST and must run with `counterfactual: true`. `searchRelevantMemories` is
+// not a read: it bumps `injection_count` on every row it returns, and that column feeds
+// `noisePenaltyClause`, `demotePinned`'s `injection_count >= N AND cited_count = 0`
+// predicate, and the `injection_count = 0` GC gate. The first version of this module took
+// a `rerun` CALLBACK, which invited the caller to run arm B wherever was convenient — and
+// the convenient place, after the delivery, is the one place it is wrong. The pre-tag
+// review reproduced both halves: rows never shown to anyone reached `injection_count = 1`,
+// and a prompt whose honest answer was `suppressed 0 / refilled 0` reported
+// `refilled: 1, setChanged: true`, purely because arm A's own bump pushed a row across the
+// >= 4 noise gate before arm B scored the corpus. CLAUDE.md already carried this rule for
+// `rerank-pool-replay` — this module quoted it and then broke it. `after` is therefore an
+// already-computed result, not a callback: the caller owns the ordering, this file owns
+// only the arithmetic.
+//
+// The difference between the two delivered sets is the price of the repair, per prompt,
+// with no reconstruction and no drift. `refilled` is what the pool puts back into the
+// freed slots — the direction the ledger calls unknown, and the reason a suppression
+// count alone would not have settled anything.
+//
+// `suppressed` is EXACT rather than estimated. A draft justified that with "arm A's
+// exclude is inert, so arm A's result IS the unexcluded search", which is unsound: arm A's
+// exclude is inert only for the ids that arrive as strings, and on a marker of plain
+// numbers it works. The conclusion survives on a different argument, which is the one to
+// keep: an id arm A already excluded cannot appear in `emitted`, so `numeric ∩ emittedIds`
+// reports the INCREMENTAL drop, which is exactly the quantity wanted. The row carries
+// `markerNumbers` beside `markerStrings` so a reader can see which regime each prompt was
+// in rather than having to trust this paragraph.
+//
+// COST AND GATING. Arm B is a second search on the UserPromptSubmit path, so it runs only
+// when CLAUDE_MEM_METRICS=1 AND the marker actually carried ids. With metrics off (the
+// default) nothing here executes and nothing is imported at cost — the module is pure ESM
+// with no dependency beyond lib/metrics.mjs.
+//
+// WHAT THIS RULER CANNOT SEE, stated because a face omitted silently is how the citation
+// replay shipped a wrong denominator: `task_imperative` is behind
+// CLAUDE_MEM_TASK_IMPERATIVE and default OFF, so on a stock install its arm is recorded as
+// `'off'` rather than dropped from the row. And this measures the `ups` face's own
+// delivery only — it says nothing about whether the reader then cited what it got.
+
+import { recordMetric } from './metrics.mjs';
+
+/** Metric `event` name. Readers filter on this. */
+export const PATHA_EXCLUDE_EVENT = 'patha_exclude';
+
+/**
+ * Mirrors lib/metrics.mjs's private `metricsEnabled`. Duplicated deliberately rather
+ * than exported from there: this module must decide whether to run a SECOND SEARCH
+ * before it calls recordMetric, and a sink that no-ops after the work is done would
+ * make the expensive half unconditional.
+ * @returns {boolean}
+ */
+export function pathAMeterEnabled() {
+  return process.env.CLAUDE_MEM_METRICS === '1';
+}
+
+/**
+ * How the marker's ids arrive, by JS type. The whole defect is a type, so the type
+ * distribution is the first thing any reading of this metric needs.
+ * @param {Array<number|string>} ids
+ * @returns {{total:number, strings:number, numbers:number, other:number}}
+ */
+export function markerTypeSplit(ids) {
+  const out = { total: 0, strings: 0, numbers: 0, other: 0 };
+  for (const id of ids || []) {
+    out.total++;
+    if (typeof id === 'string') out.strings++;
+    else if (typeof id === 'number') out.numbers++;
+    else out.other++;
+  }
+  return out;
+}
+
+/**
+ * The coercion the repair would apply, and no more than that.
+ *
+ * Event ids are namespaced `E<id>` in the marker (D#188) and are NOT observation ids.
+ * `Number('E42')` is NaN, and a NaN in an exclude Set is not merely useless — it is a
+ * second silent no-op wearing the costume of a fix. The `Number.isInteger` gate below
+ * is what excludes them, and it is the ONLY thing that does: a first version of this
+ * function carried an explicit `/^E/` skip above it, and mutating that line away left
+ * all 17 cases green, because no input reaches it that the integer gate does not also
+ * reject. Deleted rather than kept as a guard nobody can see fire (the D#197 precedent).
+ * The behaviour is still pinned by a test — what is gone is the unreachable branch.
+ *
+ * Same reasoning for anything non-integral or non-positive: an exclude set is a set of
+ * primary keys, so a value that cannot be one does not belong in it. The gate is
+ * `Number.isInteger(n) && n > 0`, not truthiness — `Number('')` and `Number(null)` are
+ * both 0, which `if (n)` would reject by accident and for the wrong reason.
+ * @param {Array<number|string>} ids
+ * @returns {Set<number>}
+ */
+export function coerceMarkerIds(ids) {
+  const out = new Set();
+  for (const raw of ids || []) {
+    const n = Number(raw);
+    if (Number.isInteger(n) && n > 0) out.add(n);
+  }
+  return out;
+}
+
+/**
+ * Rows a numerically-comparing exclude would have removed from what arm A delivered.
+ * Exact rather than estimated — see the header.
+ * @param {Array<number|string>} markerIds
+ * @param {number[]} emittedIds
+ * @returns {number[]}
+ */
+export function suppressedByWorkingExclude(markerIds, emittedIds) {
+  const numeric = coerceMarkerIds(markerIds);
+  return (emittedIds || []).filter(id => numeric.has(id));
+}
+
+/**
+ * Ids that are BOTH coercible to an observation id AND arrived as a string — i.e. the
+ * ids the shipped comparison silently fails to match. This, not "any string is present",
+ * is what makes a prompt's exclude inert.
+ *
+ * The distinction is load-bearing and a first version got it wrong. That version defined
+ * inert as `markerTypeSplit().strings > 0`, on the belief — written into four files — that
+ * UPS writes plain numbers and "only a PreToolUse emission inside the same window turns
+ * the union into strings". That belief is FALSE, and the counterexamples are in UPS
+ * itself: `scripts/user-prompt-search.js` writes `P<id>` on its prompt-fallback leg and
+ * `D<id>` on its deferred leg, and the deferred leg merges `prevIds.map(String)`, which
+ * stringifies whatever the file already held with no tool call involved.
+ *
+ * The consequence of the wrong definition ran in the opposite direction to the one the
+ * design was defending against: a marker holding ONLY `P`/`D`/`E` ids was recorded
+ * `inert: true` with `markerCoercible: 0` — a prompt whose exclude had nothing it could
+ * ever have excluded, counted into the inert population. Found by the pre-tag claims
+ * review (B5).
+ * @param {Array<number|string>} ids
+ * @returns {number[]}
+ */
+export function inertMarkerIds(ids) {
+  const out = [];
+  for (const raw of ids || []) {
+    if (typeof raw !== 'string') continue;
+    const n = Number(raw);
+    if (Number.isInteger(n) && n > 0) out.push(n);
+  }
+  return out;
+}
+
+/**
+ * Run both arms and shape the metric row. Pure with respect to the store: every DB
+ * access is the caller's `rerun` callback, so this is testable with no database and the
+ * hot path keeps its own imports.
+ *
+ * `after` is arm B's ALREADY-COMPUTED outcome, not a callback. It was a callback in the
+ * first version, which invited the caller to run arm B wherever was convenient — and the
+ * convenient place (after the delivery) is the one place it is wrong, because arm A's
+ * `injection_count` bump changes the corpus arm B then scores. The caller now owns the
+ * ordering and this function owns only the arithmetic.
+ *
+ *   `after` absent          → armB: 'skipped'
+ *   `{ rows: [...] }`       → armB: 'ok'
+ *   `{ error: '<message>' }`→ armB: 'error', with `net`/`setChanged` left UNDEFINED
+ *
+ * A failed arm must never read as a measured zero — "Δ all-zero because it did not fire"
+ * is a failure mode this repo has shipped before.
+ *
+ * @param {object} o
+ * @param {Array<number|string>} o.markerIds  ids as `pathAInjectedIds` holds them
+ * @param {Array<{id:number}>} o.emitted      arm A's delivered rows
+ * @param {{rows?: Array<{id:number}>, error?: string}|null} [o.after]
+ * @param {string} [o.imperativeArm]          'off' | 'on'
+ * @param {number|null} [o.imperativeBefore]  arm A's pick id, when the flag is on
+ * @param {number|null} [o.imperativeAfter]   arm B's pick id, when the flag is on
+ * @returns {object} the metric payload (without `event`/`ts`)
+ */
+export function measurePathAExclude({
+  markerIds, emitted, after,
+  imperativeArm = 'off', imperativeBefore = null, imperativeAfter = null,
+}) {
+  const split = markerTypeSplit(markerIds);
+  const numeric = coerceMarkerIds(markerIds);
+  const inertStrings = inertMarkerIds(markerIds);
+  const emittedIds = (emitted || []).map(r => r.id);
+  // Through the exported helper, not a second copy of `emittedIds.filter(id =>
+  // numeric.has(id))`. A first draft inlined it, which would have left the function the
+  // metric row is built from and the function the tests assert on as two implementations
+  // of one rule — the twin-drift class this repo pays for more often than any other.
+  const suppressed = suppressedByWorkingExclude(markerIds, emittedIds);
+
+  const row = {
+    markerTotal: split.total,
+    markerStrings: split.strings,
+    markerNumbers: split.numbers,
+    markerCoercible: numeric.size,
+    // Ids that are coercible AND arrived as strings: what the shipped comparison fails
+    // to match. `markerStrings` above counts every string INCLUDING `P`/`D`/`E`, which
+    // are other tables' namespaces and were never observation ids to begin with.
+    markerCoercibleStrings: inertStrings.length,
+    // The shipped exclude is inert for THIS prompt exactly when at least one id it
+    // COULD have matched arrives as a string — not merely when some string is present.
+    // See inertMarkerIds: defining it on `strings > 0` counts a `P`/`D`/`E`-only marker
+    // as inert although it had nothing excludable, inflating the very denominator this
+    // column exists to keep honest.
+    inert: inertStrings.length > 0,
+    emitted: emittedIds.length,
+    suppressed: suppressed.length,
+    suppressedIds: suppressed,
+    imperativeArm,
+  };
+
+  if (imperativeArm === 'on') {
+    row.imperativeBefore = imperativeBefore;
+    row.imperativeAfter = imperativeAfter;
+    row.imperativeChanged = imperativeBefore !== imperativeAfter;
+  }
+
+  if (after && Array.isArray(after.rows)) {
+    const afterIds = after.rows.map(r => r.id);
+    row.armB = 'ok';
+    row.delivered = afterIds.length;
+    // The number the ledger says is unknown: slots freed by the exclude that the
+    // pool refills with something else. `delivered - emitted` is the NET, and net
+    // zero does not mean nothing happened — a suppressed row replaced one-for-one
+    // reads as no change while the delivered SET is different.
+    const before = new Set(emittedIds);
+    row.refilledIds = afterIds.filter(id => !before.has(id));
+    row.refilled = row.refilledIds.length;
+    row.net = afterIds.length - emittedIds.length;
+    row.setChanged = row.suppressed > 0 || row.refilled > 0;
+  } else if (after && after.error) {
+    // Never a measured zero: `net` and `setChanged` stay undefined so a reader cannot
+    // mistake a failed arm for "the repair changed nothing".
+    row.armB = 'error';
+    row.armBError = String(after.error);
+  } else {
+    row.armB = 'skipped';
+  }
+
+  return row;
+}
+
+/**
+ * Gate + measure + append. Returns the recorded payload, or null when it did not run,
+ * so a caller (or a test) can tell "measured nothing" from "did not measure".
+ * @returns {object|null}
+ */
+export function recordPathAExclude(dbDir, opts) {
+  if (!pathAMeterEnabled()) return null;
+  if (!opts || !Array.isArray(opts.markerIds) || opts.markerIds.length === 0) return null;
+  const row = measurePathAExclude(opts);
+  recordMetric(dbDir, { event: PATHA_EXCLUDE_EVENT, ...row });
+  return row;
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.89.0",
+  "version": "3.90.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.89.0",
+      "version": "3.90.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.89.0",
+  "version": "3.90.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",
@@ -89,6 +89,7 @@
     "lib/release-digest.mjs",
     "lib/mem-override.mjs",
     "lib/injected-ids.mjs",
+    "lib/patha-exclude-meter.mjs",
     "lib/time-constants.mjs",
     "lib/keyctx-marker.mjs",
     "lib/inject-search-core.mjs",

package/source-files.mjs

@@ -141,6 +141,7 @@ export const SOURCE_FILES = [
   // scripts/user-prompt-search.js + scripts/pre-tool-recall.js. Under lib/ for
   // the same scripts-dir-rename reason as mem-override.mjs above.
   'lib/injected-ids.mjs',
+  'lib/patha-exclude-meter.mjs',
   // P2-13 (narrowed): millisecond time units, single-sourced from the four
   // modules that each declared their own DAY_MS. Leaf module, zero imports.
   'lib/time-constants.mjs',