claude-mem-lite 3.38.1 → 3.38.3

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.38.1",
+      "version": "3.38.3",
       "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.38.1",
+  "version": "3.38.3",
   "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

@@ -408,17 +408,19 @@ export function recallForFile(db, filePath, project) {
 }
 
 /**
- * Phase-2 task-imperative selection (spec 2026-06-29 §4.1): the single highest-value
- * lesson relevant to THIS prompt, for delivery at the task-prompt position under the
- * imperative template. Own gate (importance>=2 + non-empty lesson + identifier overlap
- * with the prompt, top-1) — deliberately independent of searchRelevantMemories' coverage/
+ * Phase-2 task-imperative ranking (spec 2026-06-29 §4.1): score every candidate lesson
+ * relevant to THIS prompt (importance>=2 + non-empty lesson + identifier overlap with the
+ * prompt), sorted best-first — deliberately independent of searchRelevantMemories' coverage/
  * BM25 filters so a high-value lesson is not dropped by the context-list scoring.
- * @returns {{id:number, lesson_learned:string}|null}
+ * `epochTo` (optional) restricts the pool to observations created at/before that epoch —
+ * for offline point-in-time replay (benchmark use); a no-op at every production call site,
+ * which never passes it.
+ * @returns {Array<{id:number, lesson_learned:string, importance:number, overlap:number, score:number}>}
  */
-export function selectImperativeLesson(db, userPrompt, project, excludeIds = []) {
-  if (!db || !userPrompt) return null;
+export function rankImperativeCandidates(db, userPrompt, project, excludeIds = [], { epochTo = null } = {}) {
+  if (!db || !userPrompt) return [];
   const promptIdents = new Set(extractIdents(userPrompt));
-  if (promptIdents.size === 0) return null; // no symbol anchor → no imperative (precision-first)
+  if (promptIdents.size === 0) return []; // no symbol anchor → no imperative (precision-first)
   const exclude = new Set(excludeIds);
   let rows;
   try {
@@ -432,19 +434,34 @@ export function selectImperativeLesson(db, userPrompt, project, excludeIds = [])
         AND lesson_learned IS NOT NULL
         AND TRIM(lesson_learned) != ''
         AND LOWER(TRIM(lesson_learned)) != 'none'
+        AND (? IS NULL OR created_at_epoch <= ?)
       ORDER BY importance DESC, created_at_epoch DESC
       LIMIT 50
-    `).all(project);
-  } catch { return null; }
-  let best = null, bestScore = 0;
+    `).all(project, epochTo, epochTo);
+  } catch { return []; }
+  const out = [];
   for (const r of rows) {
     if (exclude.has(r.id)) continue;
     const overlap = extractIdents(`${r.lesson_learned} ${r.title || ''}`).filter((id) => promptIdents.has(id)).length;
     if (overlap === 0) continue;
     const score = (r.importance || 2) * overlap;
-    if (score > bestScore) { bestScore = score; best = r; }
+    out.push({ id: r.id, lesson_learned: r.lesson_learned, importance: r.importance || 2, overlap, score });
   }
-  return best ? { id: best.id, lesson_learned: best.lesson_learned } : null;
+  // Array.prototype.sort is spec-guaranteed stable (ES2019+) — ties keep the pool's
+  // ORDER BY importance DESC, created_at_epoch DESC relative order, matching the old
+  // loop's strict `score > bestScore` (first-max-wins) tie-break exactly.
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}
+
+/**
+ * Phase-2 task-imperative selection: the single highest-value lesson relevant to THIS
+ * prompt — top-1 of rankImperativeCandidates, mapped to the pre-existing return shape.
+ * @returns {{id:number, lesson_learned:string}|null}
+ */
+export function selectImperativeLesson(db, userPrompt, project, excludeIds = []) {
+  const top = rankImperativeCandidates(db, userPrompt, project, excludeIds)[0];
+  return top ? { id: top.id, lesson_learned: top.lesson_learned } : null;
 }
 
 // P0 (2026-07-03): compose the subagent-dispatch injection. Given a PreToolUse

package/lib/citation-tracker.mjs

@@ -377,8 +377,51 @@ export function extractAllInjected(transcriptPath, opts = {}) {
  * @param {string} transcriptPath
  * @returns {{injected: number, cited: number, recalled: number, ratio: number}}
  */
+// pre-agent-inject.js (CLAUDE_MEM_SUBAGENT_INJECT) APPENDS formatSubagentContext to a
+// dispatched subagent's task prompt via PreToolUse updatedInput — a PROMPT-embedded
+// injection, NOT a hook attachment. extractAllInjected (the attachment path) misses it,
+// so the sidechain instrument read a false 0 ("subagents memory-blind") even while the
+// dispatch surface was live. The block is `[Project memory — surfaced by your operator's
+// claude-mem-lite ...]` followed by a `  #NN — <lesson>.` tag line.
+const SUBAGENT_INJECT_MARKER = /surfaced by your operator's claude-mem-lite/;
+// Row-anchored to the `#NN — ` tag so a #NN quoted inside the lesson body does NOT enter
+// the injected set — same discipline as INJECTED_ROW_RE for the attachment surfaces.
+const SUBAGENT_INJECT_ID_RE = /^\s{0,4}#(\d{1,7})\s+—/;
+
+/**
+ * Extract observation ids injected into a subagent's PROMPT by pre-agent-inject.js
+ * (formatSubagentContext). Only the `#NN — ` tag line counts; a body cross-reference is
+ * ignored. Returns numeric ids.
+ * @param {string|null|undefined} transcriptPath
+ * @returns {Set<number>}
+ */
+export function extractInjectedFromSubagentPrompt(transcriptPath) {
+  const ids = new Set();
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return ids; }
+  for (const line of raw.split('\n')) {
+    if (!line) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    const c = entry.message?.content;
+    const text = typeof c === 'string'
+      ? c
+      : Array.isArray(c) ? c.map((x) => (typeof x === 'string' ? x : x?.text || '')).join('\n') : '';
+    if (!text || !SUBAGENT_INJECT_MARKER.test(text)) continue;
+    for (const bl of text.split('\n')) {
+      const m = SUBAGENT_INJECT_ID_RE.exec(bl);
+      if (m) addObsId(ids, m[1]);
+    }
+  }
+  return ids;
+}
+
 export function computeThreadCiteRecall(transcriptPath) {
   const injected = extractAllInjected(transcriptPath);
+  // Subagent files carry NO hook-attachment injection; pre-agent-inject.js injects into
+  // the PROMPT (updatedInput). Fold that in so sidechain recall isn't a false 0. On a
+  // main transcript this marker is absent → no-op.
+  for (const id of extractInjectedFromSubagentPrompt(transcriptPath)) injected.add(id);
   const cited = extractCitationsFromTranscript(transcriptPath);
   let recalled = 0;
   for (const id of injected) if (cited.has(id)) recalled++;

package/mem-cli.mjs

@@ -2349,10 +2349,10 @@ function _reportSidechainCiteRecall({ days, json }) {
   out(`  main        ${pct(mainRate).padStart(6)}   recalled ${main.recalled} / injected ${main.injected}   (${main.files} transcript(s))`);
   out(`  sidechain   ${pct(sideRate).padStart(6)}   recalled ${sidechain.recalled} / injected ${sidechain.injected}   (${sidechain.files} subagent file(s), ${sidechain.withInjections} with injections)`);
   if (sidechain.files > 0 && sidechain.injected === 0) {
-    out('  → subagent transcripts exist but received ZERO memory injections: claude-mem-lite');
-    out('    hooks do NOT fire inside subagents (no PreToolUse/PostToolUse recall, no');
-    out('    SessionStart block, no mem_* tools). Subagents are memory-blind — giving them');
-    out('    memory needs a NEW surface (inject at Agent/Task dispatch), not deepening.');
+    out('  → subagent transcripts exist but none carried a detectable memory injection in');
+    out('    this window. claude-mem-lite hooks do NOT fire inside subagents; the dispatch-');
+    out('    time surface (pre-agent-inject.js, CLAUDE_MEM_SUBAGENT_INJECT) prompt-injects');
+    out('    a lesson when enabled — a 0 here means it was off or selected none for these.');
   } else if (sidechain.files === 0) {
     out('  → no subagent transcripts in window.');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.38.1",
+  "version": "3.38.3",
   "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/user-prompt-search.js

@@ -9,6 +9,7 @@ import { citeFactorClause } from '../scoring-sql.mjs';
 import { cjkPrecisionOk } from '../nlp.mjs';
 import { writeFileSync, readFileSync, existsSync, renameSync } from 'fs';
 import { join, sep } from 'path';
+import { pathToFileURL } from 'url';
 import Database from 'better-sqlite3';
 import { shouldSkip, computeEffectiveLen, detectIntent, shouldSkipByDedup, extractFiles, extractErrorSignature, DEDUP_STALE_MS, matchRegistrySkillName, detectMemOverride } from './prompt-search-utils.mjs';
 import { recommendSkill } from '../registry-recommend.mjs';
@@ -265,14 +266,15 @@ export function rowMatchesIdentifier(row, idsLower) {
 // Each row includes `bm25_raw` (pre-multiplier bm25 magnitude) alongside the
 // composite `relevance`, so callers can distinguish raw-match strength from
 // importance/type/decay inflation.
-export function searchByFts(db, queryText, project, limit, typeFilter) {
+export function searchByFts(db, queryText, project, limit, typeFilter,
+                            { nowT = Date.now(), epochTo = null } = {}) {
   const ftsQuery = sanitizeFtsQuery(queryText);
   if (!ftsQuery) return { rows: [], mode: null };
 
-  const cutoff = Date.now() - LOOKBACK_MS;
+  const cutoff = nowT - LOOKBACK_MS;
 
   const typeClause = typeFilter ? 'AND o.type = ?' : '';
-  const now = Date.now();
+  const now = nowT;
   // R1: notLowSignalTitleClause() excludes hook-llm degraded titles
   // ("Modified X", "Worked on X", "Reviewed N files:", raw error logs).
   // v26 P0: noise penalty shrinks relevance magnitude for obs with high
@@ -298,6 +300,7 @@ export function searchByFts(db, queryText, project, limit, typeFilter) {
       AND o.project = ?
       AND o.importance >= 1
       AND o.created_at_epoch > ?
+      AND (? IS NULL OR o.created_at_epoch <= ?)
       AND COALESCE(o.compressed_into, 0) = 0
       AND o.superseded_at IS NULL
       AND ${notLowSignalTitleClause('o')}
@@ -306,7 +309,7 @@ export function searchByFts(db, queryText, project, limit, typeFilter) {
     LIMIT ?
   `;
 
-  const params = [now, ftsQuery, project, cutoff];
+  const params = [now, ftsQuery, project, cutoff, epochTo, epochTo];
   if (typeFilter) params.push(typeFilter);
   params.push(limit);
 
@@ -821,4 +824,24 @@ async function main() {
 // every sibling hook script upholds). Deliberately NOT `.finally(process.exit(0))` —
 // this hook detaches a background `claude -p` search and a forced exit would kill it;
 // letting the loop drain naturally exits 0 once the detached child is unref'd.
-main().catch(() => {});
+// Import guard (mirrors benchmark/longmemeval.mjs): only auto-run when this file is
+// executed directly as the UserPromptSubmit hook, not when a benchmark/test harness
+// imports it to call searchByFts() offline (see tests/adoption-searchbyfts-snapshot.test.mjs).
+//
+// Exported as a pure predicate (side-effect-free) so a regression test can
+// exercise it directly without triggering main(). hook-launcher.mjs's
+// self-heal retry (runEntry({ bustCache: true })) re-imports this entry with
+// a cache-buster query appended (`?t=<ts>`) so Node's ESM cache doesn't
+// return the earlier ERR_MODULE_NOT_FOUND rejection, while process.argv[1]
+// stays query-less — a strict `===` here evaluated false on that retry,
+// silently skipping main() so the healed hook fire did no memory search.
+// Stripping the query before comparing fixes that without weakening the
+// normal-launcher / execFileSync direct-invocation checks (both still match
+// exactly, query or no query).
+export function isDirectInvocation(metaUrl, argv1) {
+  if (!argv1) return false;
+  return metaUrl.split('?')[0] === pathToFileURL(argv1).href;
+}
+if (isDirectInvocation(import.meta.url, process.argv[1])) {
+  main().catch(() => {});
+}