claude-mem-lite 2.80.1 → 2.81.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.80.1",
+      "version": "2.81.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.80.1",
+  "version": "2.81.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/hook.mjs

@@ -61,6 +61,7 @@ import { checkForUpdate } from './hook-update.mjs';
 import { handleLLMOptimize } from './hook-optimize.mjs';
 import { silentAutoAdopt, hasAutoAdoptMarker } from './adopt-cli.mjs';
 import { emitV270UpgradeBanner } from './lib/upgrade-banner.mjs';
+import { loadCiteBackForEpisode } from './lib/cite-back-hint.mjs';
 // plugin-cache-guard.mjs loaded dynamically — pre-2.31.2 installs that auto-upgraded
 // from an older hook-update.mjs SOURCE_FILES (which did not list this module) would
 // crash on static import. Degrade gracefully to no-op when the module is absent.
@@ -196,6 +197,12 @@ function flushEpisode(episode, hookEventName = 'PostToolUse') {
           const filesHint = uniqueFiles.length > 0 ? ` (${uniqueFiles.join(', ')})` : '';
           lines.push(`[mem] 💡 error→fix pattern${filesHint} — consider: mem_save(type="bugfix", lesson_learned="<root cause + fix>")`);
         }
+        // v2.81: cite-back hint — fires when this episode edits a file that
+        // PreToolUse:Read/Edit nudged earlier in the same session. Precision
+        // signal (we know the file was warned about); orthogonal to the
+        // error→fix pattern above and may co-fire.
+        const citeBack = loadCiteBackForEpisode(episode, RUNTIME_DIR);
+        if (citeBack) lines.push(citeBack);
         process.stdout.write(JSON.stringify({
           suppressOutput: true,
           hookSpecificOutput: {

package/lib/cite-back-hint.mjs

@@ -0,0 +1,70 @@
+// claude-mem-lite: PostToolUse cite-back hint builder.
+//
+// Fires when a flushed episode edits a file that PreToolUse:Read/Edit had
+// nudged earlier in the same session — the canonical "you fixed something we
+// warned about, save the lesson?" moment.
+//
+// Pure function: takes an episode + the session-scoped pre-recall cooldown
+// object and returns a hint string (or null). Cooldown I/O lives elsewhere so
+// this stays unit-testable without disk fixtures.
+//
+// Cooldown schema (post-v2.81): { "<path>": { ts: <number>, lessonIds: [#NN, ...] } }
+// Legacy schema   (pre-v2.81):  { "<path>": <number> } — tolerated, never emits.
+
+import { basename, join } from 'path';
+import { readFileSync } from 'fs';
+import { EDIT_TOOLS } from '../utils.mjs';
+
+const MAX_FILES = 2;
+
+export function buildCiteBackHint(episode, cooldown) {
+  if (!episode || !cooldown) return null;
+  const entries = episode.entries;
+  if (!Array.isArray(entries) || entries.length === 0) return null;
+
+  const seen = new Set();
+  const matches = [];
+  for (const e of entries) {
+    if (!EDIT_TOOLS.has(e.tool)) continue;
+    for (const file of e.files || []) {
+      if (seen.has(file)) continue;
+      const entry = cooldown[file];
+      if (!entry || typeof entry !== 'object') continue;
+      const ids = Array.isArray(entry.lessonIds) ? entry.lessonIds : null;
+      if (!ids || ids.length === 0) continue;
+      seen.add(file);
+      matches.push({ file, ids });
+      if (matches.length >= MAX_FILES) break;
+    }
+    if (matches.length >= MAX_FILES) break;
+  }
+
+  if (matches.length === 0) return null;
+
+  const lines = ['[mem] 💡 Cite-back: you edited file(s) that received PreToolUse lessons this session.'];
+  for (const m of matches) {
+    const fname = basename(m.file);
+    const idList = m.ids.map(id => `#${id}`).join(', ');
+    lines.push(`  • ${fname} ← ${idList} — if you fixed it: /lesson --file ${fname} "<root cause + fix>"`);
+  }
+  return lines.join('\n');
+}
+
+// Path scheme MUST mirror scripts/pre-tool-recall.js cooldownPathFor() — drift
+// silently zeros cite-back across the release. Pinned by tests/cite-back-hint.test.mjs
+// 'sanitizes the sessionId the same way pre-tool-recall.js does'.
+function cooldownPathFor(sessionId, runtimeDir) {
+  const safe = String(sessionId).replace(/[^a-zA-Z0-9_.-]/g, '-').slice(0, 64);
+  return join(runtimeDir, `pre-recall-cooldown-${safe}.json`);
+}
+
+export function loadCiteBackForEpisode(episode, runtimeDir) {
+  if (!episode || !episode.sessionId || !runtimeDir) return null;
+  let cooldown;
+  try {
+    cooldown = JSON.parse(readFileSync(cooldownPathFor(episode.sessionId, runtimeDir), 'utf8'));
+  } catch {
+    return null;
+  }
+  return buildCiteBackHint(episode, cooldown);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.80.1",
+  "version": "2.81.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -57,6 +57,7 @@
     "lib/low-signal-patterns.mjs",
     "lib/private-strip.mjs",
     "lib/citation-tracker.mjs",
+    "lib/cite-back-hint.mjs",
     "lib/summary-extractor.mjs",
     "lib/id-routing.mjs",
     "lib/err-sampler.mjs",

package/scripts/pre-tool-recall.js

@@ -49,6 +49,15 @@ function readCooldown(cooldownPath) {
   try { return JSON.parse(readFileSync(cooldownPath, 'utf8')); } catch { return {}; }
 }
 
+// v2.81: cooldown entries are {ts, lessonIds} objects so the PostToolUse
+// cite-back hint can name the lessons that were nudged. Legacy entries
+// (pre-v2.81) are bare numbers — entryTimestamp() reads both shapes.
+function entryTimestamp(v) {
+  if (typeof v === 'number') return v;
+  if (v && typeof v === 'object' && typeof v.ts === 'number') return v.ts;
+  return 0;
+}
+
 function writeCooldown(cooldownPath, data, isSessionScoped) {
   try {
     mkdirSync(RUNTIME_DIR, { recursive: true });
@@ -59,7 +68,8 @@ function writeCooldown(cooldownPath, data, isSessionScoped) {
     const cleaned = isSessionScoped ? data : {};
     if (!isSessionScoped) {
       for (const [k, v] of Object.entries(data)) {
-        if (now - v < STALE_MS) cleaned[k] = v;
+        const ts = entryTimestamp(v);
+        if (ts && now - ts < STALE_MS) cleaned[k] = v;
       }
     }
     writeFileSync(cooldownPath, JSON.stringify(cleaned));
@@ -124,7 +134,8 @@ try {
   if (isSessionScoped) {
     if (cooldown[filePath]) process.exit(0); // already recalled this file in-session
   } else {
-    if (cooldown[filePath] && (now - cooldown[filePath]) < COOLDOWN_MS) process.exit(0);
+    const ts = entryTimestamp(cooldown[filePath]);
+    if (ts && (now - ts) < COOLDOWN_MS) process.exit(0);
   }
 
   // Open DB readonly
@@ -275,7 +286,10 @@ try {
     // Cooldown applies on ALL branches (including silent-Read) so subsequent
     // calls on the same file in the same session don't re-query — preserving
     // the per-filePath invariant that underpins Read→Edit dedup.
-    cooldown[filePath] = now;
+    // v2.81: record the emitted lesson IDs so flushEpisode (hook.mjs) can
+    // build the PostToolUse cite-back hint when the user actually edits the
+    // file. Empty array on no-lesson branches keeps the schema uniform.
+    cooldown[filePath] = { ts: now, lessonIds: allRows.map(r => r.id) };
     writeCooldown(cooldownPath, cooldown, isSessionScoped);
   } catch (e) {
     // Silent failure — never block editing, but record for self-observation.

package/source-files.mjs

@@ -40,6 +40,7 @@ export const SOURCE_FILES = [
   'lib/low-signal-patterns.mjs',
   'lib/private-strip.mjs',
   'lib/citation-tracker.mjs',
+  'lib/cite-back-hint.mjs',
   'lib/summary-extractor.mjs',
   'lib/id-routing.mjs',
   'lib/err-sampler.mjs',