claude-mem-lite 3.85.1 → 3.87.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.85.1",
+      "version": "3.87.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.85.1",
+  "version": "3.87.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-context.mjs

@@ -61,6 +61,65 @@ export function computeAdaptiveWindows(db, project) {
   }
 }
 
+// D#192 (filed as D#189, re-scoped after measurement). These two are REACHABILITY bounds, not ranking bounds — the D#172 shape, and
+// the fifth surface it has been found on. Both SELECTs order by pure `created_at_epoch
+// DESC`; the JS below then re-sorts every candidate by `valueDensity`, a composite of
+// typeQuality x impBoost(1.0/1.5/2.0) x lessonBoost(1.0/1.3) / sqrt(cost) whose dynamic
+// range is far wider than the (1,2] that recency contributes. So the key the SQL sorts
+// on barely participates in the final order, and anything past the LIMIT is unreachable
+// however well it scores.
+//
+// Named rather than inline so benchmark/keyctx-pool-replay.mjs can patch a twin and
+// price a change to them. Keep the `export const NAME = <int>;` shape — that ruler
+// patches the DECLARATION by regex and throws when the anchor moves.
+//
+// OBS was 50 through v3.86.0 and is now an OOM backstop, not a relevance gate. What the
+// ruler measured before the change (2026-09-02T06:11Z, 11 projects with >=20 live rows,
+// budget 2000, AGAINST THE 50/10 TREE — reproduce with `--population --ref-obs 50
+// --ref-sess 10` and with `--wide-obs 50 --wide-sess 10`, which runs the comparison
+// backwards; the bare command now reports 0/11 because shipped is the wider bound):
+// the 50-row bound truncated the pool in 3 of 11 projects, and lifting it
+// alone moved the injected block in 2 of 11 — 8 rows newly reachable against 2 displaced,
+// for +81 and +16 tokens. Selection here is NOT monotone, so a displaced row is a real
+// cost and the ruler prints it as a first-class number (`--why-displaced` names the rows
+// and the gate that dropped each).
+//
+// Both displaced rows lost their slot to the 3-per-type diversity cap. That is not a
+// three-way discrimination: the token budget does not bind on this corpus (651 of 2000 in
+// the widest arm's largest project) and the file-overlap `continue` below is UNREACHABLE
+// (D#197) — so the cap is currently the only gate that can fire.
+//
+// 200 is ~2x the largest pool observed (107). The ruler CANNOT distinguish 200 from 500
+// on this corpus — every bound >= the largest pool is one arm, identical in both
+// selection and cost — so this value is a headroom choice, not a measured optimum.
+// computeAdaptiveWindows NARROWS the windows as velocity rises (tier3 60d -> 30d -> 14d),
+// so activity counteracts pool growth instead of driving it: the largest pool here is the
+// lowest-velocity high-volume project (1.14 obs/day, 107 rows) while the only project a
+// band up has 2.9x the velocity and 29% of the pool. A draft of this comment had that
+// backwards.
+//
+// Cost is PER PROJECT: ~2.7x where the pool is 107, ~2.0x at 59, ~1.5x at 62, and
+// unchanged (inferred, not measured) for the eight projects whose pool never reached 50.
+// Once per SessionStart, both arms in the low single-digit milliseconds. It is NOT a clean
+// function of pool growth — the 59-row project grows less than the 62-row one and costs
+// more, on two independent harnesses, because fixed per-call work (SQL fetch,
+// estimateTokens, JSON.parse, the unchanged summary half) sets the denominator. Three
+// drafts were wrong here in three ways: a point estimate (2.65x), a global range
+// (2.1x-3.8x) no measurement produced, and a causal claim n=3 refutes. Absolute
+// milliseconds are not quotable. Re-derive with `--cost --wide-obs 50 --wide-sess 10
+// --project <p>`, which prices the widening in the correct direction.
+//
+// SESS stays 10 DELIBERATELY, and the discriminator is `sessDisplaced = 0` in 11 of 11
+// projects, not the observation column. Widening it to 40 displaces no summary at all —
+// it is PURELY ADDITIVE, so that LIMIT is a volume cap and not the D#172 shape, which is
+// the actual reason it does not need lifting. (It also changed zero observations, but
+// that only says the obs side is unaffected.) What widening does buy is 130 newly injected
+// summaries, roughly tripling the emitted block on the largest projects. It truncates MORE
+// projects than the obs bound, 5 of 11 against 3 of 11, which is what made the original
+// review propose it first; truncation count is not harm.
+export const KEYCTX_POOL_OBS = 200;
+export const KEYCTX_POOL_SESS = 10;
+
 /**
  * Select observations and sessions within a token budget using greedy knapsack.
  * Scores candidates by recency * importance, picks highest value-density first.
@@ -91,7 +150,7 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
         OR (created_at_epoch > ? AND importance >= 3)
       )
     ORDER BY created_at_epoch DESC
-    LIMIT 50
+    LIMIT ${KEYCTX_POOL_OBS}
   `).all(project, tier1Ago, tier2Ago, tier3Ago);
 
   const sessPool = db.prepare(`
@@ -99,7 +158,7 @@ export function selectWithTokenBudget(db, project, budget = 2000) {
     FROM session_summaries
     WHERE project = ? AND created_at_epoch > ?
     ORDER BY created_at_epoch DESC
-    LIMIT 10
+    LIMIT ${KEYCTX_POOL_SESS}
   `).all(project, now_ms - windows.sessWindow);
 
   const selectedObs = [];

package/hook-update.mjs

@@ -21,6 +21,7 @@ import { httpConnectProxyFor, getViaConnectProxy } from './lib/proxy-fetch.mjs';
 import { acquireLock } from './lib/proc-lock.mjs';
 import { atomicWriteFileSync } from './lib/atomic-write.mjs';
 import { verifyReleaseFiles, verifyManifestSignature } from './lib/release-digest.mjs';
+import { detectInstallShape } from './lib/install-shape.mjs';
 
 // ── Configuration ──────────────────────────────────────────
 const GITHUB_REPO = 'sdsrss/claude-mem-lite';
@@ -156,8 +157,47 @@ export function isUpdateCheckDue() {
   } catch { return false; }
 }
 
+// D#187. `CLAUDE_PLUGIN_ROOT` is set in every hook and MCP process Claude Code
+// spawns, so inside those the env var answers "am I a plugin install?" perfectly —
+// which is why v3.84.1's fix, which reads it, was enough THERE. It is not set in a
+// plain terminal, and a plugin-only user typing `claude-mem-lite update` therefore
+// fell off both plugin paths at once: getCurrentVersion() returned '0.0.0' (so every
+// release compares as newer, forever), and isPluginMode() was false, so allowInstall
+// defaulted to true and downloadAndInstall laid a full managed tree into
+// ~/.claude-mem-lite — silently converting a plugin-only install into the hybrid
+// whose two trees D#184 documents drifting apart.
+//
+// Same root cause as PR #17: process ENVIRONMENT was the only install-shape
+// evidence consulted. detectInstallShape() reads the FILESYSTEM instead, so it
+// answers the same in a hook, in a terminal, and in a subprocess.
+//
+// Memoised per process. The reason first written here was wrong and the pre-tag review
+// traced it out: it claimed the memo keeps installExtractedRelease()'s post-install
+// isPluginMode() call stable across the managed-tree write. That call cannot depend on
+// this fallback at all — every path reaching installExtractedRelease is a plugin process
+// (checkForUpdate cannot reach downloadAndInstall while pluginMode is true, and
+// syncDataDirFromCache is only called from scripts/launch.mjs and
+// scripts/hook-launcher.mjs), so CLAUDE_PLUGIN_ROOT is set and isPluginMode()
+// short-circuits before pluginOnlyInstall() is consulted, before AND after the write.
+// What the memo actually buys: one readdirSync per process instead of one per call, and
+// a stable answer inside a long-lived MCP server whose plugin cache may be pruned or
+// re-populated underneath it while it runs.
+let shapeMemo;
+function installShape() {
+  if (shapeMemo === undefined) {
+    try { shapeMemo = detectInstallShape({ installDir: INSTALL_DIR }); } catch { shapeMemo = null; }
+  }
+  return shapeMemo;
+}
+
+/** True when this machine runs the plugin and has NO managed code install to update. */
+function pluginOnlyInstall() {
+  const shape = installShape();
+  return Boolean(shape && !shape.managed && shape.activePluginVersion);
+}
+
 function isPluginMode() {
-  return Boolean(process.env.CLAUDE_PLUGIN_ROOT);
+  return Boolean(process.env.CLAUDE_PLUGIN_ROOT) || pluginOnlyInstall();
 }
 
 // ── Dev Mode Detection ─────────────────────────────────────
@@ -313,6 +353,17 @@ export function getCurrentVersion() {
       if (pkg.version) return pkg.version;
     } catch { /* fall through to the last resort */ }
   }
+  // D#187: no env var in a plain terminal, so ask the filesystem which plugin
+  // version this machine actually runs. Without this a plugin-only user's
+  // `claude-mem-lite update` reads 0.0.0 and every release compares as newer.
+  const active = installShape()?.activePluginVersion;
+  if (active) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(active.root, 'package.json'), 'utf8'));
+      if (pkg.version) return pkg.version;
+    } catch { /* the cache dir name IS the version — use it rather than 0.0.0 */ }
+    if (active.version) return active.version;
+  }
   return '0.0.0';
 }
 

package/lib/citation-tracker.mjs

@@ -115,6 +115,85 @@ export function extractCitationsFromTranscript(transcriptPath, opts = {}) {
   return ids;
 }
 
+/**
+ * D#179 prerequisite measurement: split each cited id into the responses that
+ * ACTED while naming it and the responses that only TALKED about it.
+ *
+ * `applyCitationDecay` promotes on any `#NN` in assistant text, so writing a release
+ * note, an audit, or a review that discusses a memory promotes that memory — including,
+ * self-referentially, a note observing that the memory is about to be evicted. Nothing
+ * downstream distinguishes "changed the code this lesson describes" from "mentioned the
+ * lesson's number". This function supplies the discriminator the deferred item asks for
+ * so the size of the contamination can be counted before anything is redesigned.
+ *
+ * The unit is a RESPONSE, keyed by `requestId` — one model turn, whose entries carry
+ * thinking / text / tool_use blocks under a shared id. That granularity is the point:
+ * a whole user-to-user exchange almost always contains some tool call, so bounding on
+ * user messages would classify nearly everything as "applied" and measure nothing.
+ *
+ * The key falls back `requestId || message.id || uuid`. In practice `message.id` carries
+ * every real Claude Code assistant entry that lacks a requestId, and it is still a
+ * per-response key, so the uuid arm is close to unreachable in production and exists only
+ * so a keyless entry is never merged into a shared bucket. What must NOT happen is any
+ * grouping coarser than one response: one tool call anywhere in a coarser bucket would
+ * mark every id in it as acted on, and the measurement would report no contamination on
+ * any coding session. (The pre-tag review pointed out that the earlier version of this
+ * sentence named only the uuid arm, and that the one test for it constructs a shape
+ * production never emits.)
+ *
+ * Returns a Map keyed by id: `{ withTool, textOnly }` response counts. An id is a pure
+ * MENTION when `withTool === 0`.
+ *
+ * NEITHER SIDE IS A BOUND, and an earlier draft of this comment claimed one. The proxy
+ * errs in both directions: naming an id in a response that also calls a tool is only
+ * co-occurrence, not evidence the lesson was followed (over-counts `withTool`); and an
+ * agent that acts in one response and cites the lesson in a later summary response gets
+ * classified pure-mention despite having applied it (over-counts `textOnly`). Use the
+ * split to size the question, not to settle it.
+ *
+ * @param {string} transcriptPath
+ * @param {object} [opts]
+ * @param {boolean} [opts.mainOnly=true] skip sidechain (subagent) records
+ * @returns {Map<number, {withTool: number, textOnly: number}>}
+ */
+export function classifyCitationContext(transcriptPath, opts = {}) {
+  const { mainOnly = true } = opts;
+  // requestId -> { ids:Set<number>, tool:boolean }
+  const responses = new Map();
+  for (const entry of readTranscriptEntries(transcriptPath)) {
+    if (entry.type !== 'assistant' || !entry.message) continue;
+    if (mainOnly && entry.isSidechain === true) continue;
+    const content = entry.message.content;
+    if (!Array.isArray(content)) continue;
+    const key = entry.requestId || entry.message.id || entry.uuid;
+    if (!key) continue;
+    let r = responses.get(key);
+    if (!r) { r = { ids: new Set(), tool: false }; responses.set(key, r); }
+    for (const block of content) {
+      if (block.type === 'tool_use') { r.tool = true; continue; }
+      // Only `text` blocks count as citing. `thinking` is deliberately excluded:
+      // extractCitationsFromTranscript scores text only, and the whole point is to
+      // classify the same numerator the decay loop acts on, not a wider one.
+      if (block.type !== 'text' || typeof block.text !== 'string') continue;
+      CITATION_RE.lastIndex = 0;
+      let m;
+      while ((m = CITATION_RE.exec(block.text))) {
+        const id = Number(m[1]);
+        if (Number.isInteger(id) && id > 0 && id < 1e7) r.ids.add(id);
+      }
+    }
+  }
+  const out = new Map();
+  for (const { ids, tool } of responses.values()) {
+    for (const id of ids) {
+      let e = out.get(id);
+      if (!e) { e = { withTool: 0, textOnly: 0 }; out.set(id, e); }
+      if (tool) e.withTool++; else e.textOnly++;
+    }
+  }
+  return out;
+}
+
 /**
  * Compute cite-recall stats for one transcript: how many of the `#NN`
  * references that surfaced in non-assistant content (hook injections, system

package/lib/injected-ids.mjs

@@ -28,6 +28,73 @@ export function injectedIdsFileName(project, sessionId) {
   return `${base}-${safe}`;
 }
 
+/**
+ * Namespace prefix for an id written into the shared injected-ids marker.
+ *
+ * D#188. The marker file is a UNION across hooks and across tables, and the
+ * convention for keeping those tables apart already existed — user-prompt-search.js
+ * writes `P<id>` for user_prompts rows and `D<id>` for deferred rows, with the
+ * comment "so obs ids can't collide in the shared injected-ids file". Observations
+ * are the incumbent namespace and stay bare. EVENTS were the one table that never
+ * got a prefix, even though the line three above pre-tool-recall.js's dedup filter
+ * says in as many words that "events share the numeric id space with observations"
+ * — the `src` tag added to carry exactly that distinction was not consulted by the
+ * dedup predicate sitting next to it.
+ *
+ * The consequence, measured on the live store (3747 observations, 91.6% of observation
+ * ids also existing as an event id, 2026-09-01T19:56Z): a UPS-injected observation #42
+ * made event #42 unreachable to the PreToolUse face for the 5-minute window, and vice
+ * versa. Replaying every real session's UPS-injected id set against the injectable
+ * events of the project the SESSION ran in: **14 collisions across 11 of 60 sessions
+ * (18.3%)**, 2026-09-01T20:17Z.
+ *
+ * WHICH PROJECT, precisely, because the draft got this wrong while arguing about
+ * populations. `scripts/pre-tool-recall.js` does `const project = inferProject()` once
+ * 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 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,'[]')`;
+ * session project recovered by matching each transcript directory against the DB's own
+ * project list (forward map, since flattening `/` and `_` to `-` is not invertible).
+ * Dropping the project condition entirely reports 72 in 41 — a population the
+ * project-filtered query can never reach.
+ *
+ * A SECOND consequence was claimed here before v3.86.0 was tagged and is FALSE, so it
+ * is recorded rather than deleted: bare event ids do flow into hook.mjs's
+ * `pathAInjectedIds`, which is handed to searchRelevantMemories and
+ * rankImperativeCandidates as an OBSERVATION exclude list — but they suppress
+ * NOTHING there, because `mergeCrossHookInjected` writes every id as a STRING and
+ * both consumers test `new Set(excludeIds).has(r.id)` against a NUMBER out of
+ * 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.
+ *
+ * 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
+ * format version, because a 5-minute window of the PRE-EXISTING behaviour is a
+ * smaller cost than a schema every reader has to branch on.
+ *
+ * @param {number|string} id
+ * @param {'obs'|'evt'} [src]
+ * @returns {string}
+ */
+export function injectedIdKey(id, src = 'obs') {
+  return src === 'evt' ? `E${id}` : String(id);
+}
+
 /**
  * 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/stats-quality.mjs

@@ -4,6 +4,7 @@
 // collide with CLI's `out()` stdout-write pattern.
 
 import { buildNotLowSignalSql } from './low-signal-patterns.mjs';
+import { liveObsFilterSql } from './inject-search-core.mjs';
 import { truncate } from '../format-utils.mjs';
 import { COMPRESSED_PENDING_PURGE } from '../utils.mjs';
 
@@ -23,6 +24,26 @@ export function computeNoiseGauge({ liveTotal, lowValCount, lowSignalCount }) {
   };
 }
 
+// D#191: the rule above is a rule about POPULATIONS, and until v3.86.0 it had only
+// been applied to computeNoiseGauge — a pure function that takes `liveTotal` from its
+// caller. Every query below ran on a bare `FROM observations`, so `stats --quality`
+// rendered ratios over all rows (compressed + superseded included) under labels that
+// name no population. Numerator and denominator were paired, so each ratio was
+// internally consistent; what was wrong was the population it described. Measured on
+// the live store 2026-09-01 (3742 rows total, 2284 live): all-time Lesson rate read
+// 59.6% where the live store is 92.9%, and all-time LOW_SIGNAL read 22.9% where the
+// live store is 1.1% — compression retires exactly the low-signal, lesson-less rows,
+// so an all-rows denominator reports a store roughly three decades of quality worse
+// than the one retrieval actually searches.
+//
+// `days` is user-settable (`stats --quality --days N`), so this is NOT confined to the
+// all-time bracket: the wider the window, the more compressed rows it sweeps in. The
+// filter is therefore applied to the window and per-type queries too, not only to the
+// two the review named, and all three now describe one population — the live corpus.
+//
+// Deliberately NOT filtered: `purgeRow`, whose entire subject is compressed rows.
+const LIVE = liveObsFilterSql('');
+
 export function computeQualityStats(db, { project, days }) {
   const projectFilter = project ? 'AND project = ?' : '';
   const baseParams = project ? [project] : [];
@@ -53,7 +74,7 @@ export function computeQualityStats(db, { project, days }) {
       COALESCE(SUM(CASE WHEN type = 'bugfix' THEN 1 ELSE 0 END), 0) as bugfix_total,
       COALESCE(SUM(CASE WHEN type = 'bugfix' AND ${unresolvedNarrativeExpr} THEN 1 ELSE 0 END), 0) as bugfix_unresolved
     FROM observations
-    WHERE created_at_epoch >= ? ${projectFilter}
+    WHERE created_at_epoch >= ? AND ${LIVE} ${projectFilter}
   `).get(cutoff, ...baseParams);
 
   const allTimeRow = db.prepare(`
@@ -62,7 +83,7 @@ export function computeQualityStats(db, { project, days }) {
       COALESCE(SUM(CASE WHEN lesson_learned IS NOT NULL AND lesson_learned != '' THEN 1 ELSE 0 END), 0) as with_lesson,
       COALESCE(SUM(CASE WHEN ${lowSignalIsMatchExpr} THEN 1 ELSE 0 END), 0) as low_signal
     FROM observations
-    WHERE 1=1 ${projectFilter}
+    WHERE ${LIVE} ${projectFilter}
   `).get(...baseParams);
 
   const typeRows = db.prepare(`
@@ -72,7 +93,7 @@ export function computeQualityStats(db, { project, days }) {
       COALESCE(SUM(CASE WHEN COALESCE(access_count, 0) > 0 THEN 1 ELSE 0 END), 0) as accessed,
       COALESCE(SUM(CASE WHEN lesson_learned IS NOT NULL AND lesson_learned != '' THEN 1 ELSE 0 END), 0) as with_lesson
     FROM observations
-    WHERE created_at_epoch >= ? ${projectFilter}
+    WHERE created_at_epoch >= ? AND ${LIVE} ${projectFilter}
     GROUP BY type
     ORDER BY total DESC
   `).all(cutoff, ...baseParams);
@@ -82,7 +103,7 @@ export function computeQualityStats(db, { project, days }) {
     FROM observations
     WHERE lesson_learned IS NOT NULL AND lesson_learned != ''
       AND COALESCE(access_count, 0) > 0
-      AND COALESCE(compressed_into, 0) = 0
+      AND ${LIVE}
       ${projectFilter}
     ORDER BY ac DESC
     LIMIT 5
@@ -109,7 +130,9 @@ export function formatQualityReport(data) {
   const lines = [];
   lines.push(`[mem] Quality snapshot${scope} — window: ${days}d`);
   lines.push('────────────────────────────────────────────────────');
-  lines.push(`  Writes (${days}d):     ${windowRow.total} observations`);
+  // Every ratio below divides live rows by live rows (D#191) — say so once, here,
+  // rather than qualifying each label and still leaving the brackets ambiguous.
+  lines.push(`  Writes (${days}d):     ${windowRow.total} live observations (compressed/superseded excluded throughout)`);
 
   const lessonPct = pct(windowRow.with_lesson, windowRow.total);
   const allLessonPct = pct(allTimeRow.with_lesson, allTimeRow.total);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.85.1",
+  "version": "3.87.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.85.1",
+      "version": "3.87.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.85.1",
+  "version": "3.87.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/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 } from '../lib/injected-ids.mjs';
+import { injectedIdsFileName, injectedIdKey } 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';
@@ -592,8 +592,12 @@ try {
       ...rows.map(r => ({ ...r, src: 'obs' })),
       ...eventRows.map(r => ({ ...r, src: 'evt' })),
     ];
+    // D#188: compare on the NAMESPACED key, not the bare number. The `src` tag two
+    // comments up exists precisely because the two tables share an id space; the
+    // predicate that consumed it did not use it, so an observation injected by UPS
+    // silently blocked the same-numbered event and vice versa.
     const dedupedRows = crossHookSeen.size > 0
-      ? sourcedRows.filter(r => !crossHookSeen.has(String(r.id)))
+      ? sourcedRows.filter(r => !crossHookSeen.has(injectedIdKey(r.id, r.src)))
       : sourcedRows;
 
     // Merge: observations first (they carry richer lesson_learned), then events.
@@ -746,7 +750,13 @@ try {
     // 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.
-    mergeCrossHookInjected(project, allRows.map(r => r.id), sessionId);
+    // 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
+    // pathAInjectedIds; it reaches there, but suppresses nothing, because this
+    // function stringifies every id and that consumer compares against a numeric
+    // row id. That inertness is a separate live defect — D#193.)
+    mergeCrossHookInjected(project, allRows.map(r => injectedIdKey(r.id, r.src)), sessionId);
   } catch (e) {
     // Silent failure — never block editing, but record for self-observation.
     recordHookError('pre-recall:query', e, RUNTIME_DIR, { filePath });