claude-mem-lite 2.50.0 → 2.52.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.50.0",
+      "version": "2.52.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.50.0",
+  "version": "2.52.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli/doctor.mjs

@@ -12,7 +12,32 @@ export async function cmdDoctor(db, args) {
   if (args.includes('--benchmark')) {
     const { runBenchmark } = await import('../lib/doctor-benchmark.mjs');
     const project = inferProject();
-    const result = runBenchmark(db, { project });
+    // Sample recent user prompts so the CLI report has non-null injection_rate
+    // and hook latency. Without this, runBenchmark's prompts default of [] makes
+    // every metric 0/null — a dead command from the user's perspective. Tests
+    // bypass this CLI layer and call runBenchmark() directly, so the lib API
+    // contract (default prompts=[]) is unchanged.
+    let prompts = [];
+    try {
+      const limitIdx = args.indexOf('--prompts-limit');
+      let limit = 50;
+      if (limitIdx >= 0 && args[limitIdx + 1]) {
+        const parsed = parseInt(args[limitIdx + 1], 10);
+        if (Number.isFinite(parsed) && parsed > 0 && parsed <= 1000) limit = parsed;
+      }
+      const rows = db.prepare(`
+        SELECT p.prompt_text
+        FROM user_prompts p
+        JOIN sdk_sessions s ON p.content_session_id = s.content_session_id
+        WHERE s.project = ?
+          AND p.prompt_text IS NOT NULL
+          AND length(p.prompt_text) >= 15
+        ORDER BY p.created_at_epoch DESC
+        LIMIT ?
+      `).all(project, limit);
+      prompts = rows.map(r => r.prompt_text).filter(Boolean);
+    } catch { /* missing/empty tables on a fresh DB → leave prompts=[] */ }
+    const result = runBenchmark(db, { project, prompts });
     out(JSON.stringify(result, null, 2));
     return;
   }

package/hook.mjs

@@ -27,6 +27,7 @@ import {
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
   makeEntryDesc, scrubSecrets, EDIT_TOOLS, debugCatch, debugLog,
   COMPRESSED_AUTO, COMPRESSED_PENDING_PURGE, isoWeekKey, OBS_BM25,
+  computeMinHash, estimateJaccardFromMinHash, jaccardSimilarity,
 } from './utils.mjs';
 import {
   readEpisodeRaw, episodeFile,
@@ -747,7 +748,8 @@ async function handleSessionStart() {
         `).run();
         if (boosted.changes > 0) debugLog('DEBUG', 'auto-maintain', `boosted ${boosted.changes} frequently-accessed observations`);
 
-        // Auto-dedup: merge near-identical observations (same title, same project, within 1h)
+        // Auto-dedup (exact): merge identical-title observations within 1h.
+        // Catches rapid duplicate writes (same hook firing twice, race conditions).
         const dupPairs = db.prepare(`
           SELECT a.id as keep_id, b.id as remove_id
           FROM observations a
@@ -765,6 +767,55 @@ async function handleSessionStart() {
           debugLog('DEBUG', 'auto-maintain', `auto-deduped ${dupPairs.length} near-identical observations`);
         }
 
+        // Auto-dedup (fuzzy): catches near-identical titles that exact-match
+        // misses across larger time windows — e.g. episode-batch titles like
+        // "Modified A.mjs, B.mjs" vs "Modified B.mjs, A.mjs" written days apart.
+        // MinHash pre-filter (≥0.7) cuts the O(N²) scan; Jaccard ≥0.95 stays
+        // well clear of legit "two updates same area" pairs (those typically
+        // score 0.7–0.85, surfaced via `maintain scan` for manual review).
+        // Bounded by ${SCAN_LIMIT} recent rows × ${FUZZY_MAX_MERGES}-merge cap.
+        if (!process.env.CLAUDE_MEM_SKIP_AUTO_DEDUP_FUZZY) {
+          const SCAN_LIMIT = 500;
+          const FUZZY_MAX_MERGES = 20;
+          const FUZZY_THRESHOLD = 0.95;
+          const MINHASH_PREFILTER = 0.7;
+          const recent = db.prepare(`
+            SELECT id, title, importance, created_at_epoch
+            FROM observations
+            WHERE COALESCE(compressed_into, 0) = 0
+              AND superseded_at IS NULL
+              AND created_at_epoch > ?
+              AND title IS NOT NULL AND title != ''
+            ORDER BY created_at_epoch DESC LIMIT ${SCAN_LIMIT}
+          `).all(STALE_AGE);
+          if (recent.length >= 2) {
+            const titles = recent.map(r => r.title.trim());
+            const minhashes = titles.map(t => t ? computeMinHash(t) : null);
+            const fuzzyRemoveIds = [];
+            const removed = new Set();
+            outer: for (let i = 0; i < recent.length; i++) {
+              if (!minhashes[i] || removed.has(recent[i].id)) continue;
+              for (let j = i + 1; j < recent.length; j++) {
+                if (!minhashes[j] || removed.has(recent[j].id)) continue;
+                if (estimateJaccardFromMinHash(minhashes[i], minhashes[j]) < MINHASH_PREFILTER) continue;
+                if (jaccardSimilarity(titles[i], titles[j]) < FUZZY_THRESHOLD) continue;
+                // Keep the higher-importance row; tiebreak by older (lower id wins access history)
+                const keep = (recent[i].importance ?? 1) >= (recent[j].importance ?? 1) ? recent[i] : recent[j];
+                const remove = keep === recent[i] ? recent[j] : recent[i];
+                fuzzyRemoveIds.push(remove.id);
+                removed.add(remove.id);
+                if (fuzzyRemoveIds.length >= FUZZY_MAX_MERGES) break outer;
+              }
+            }
+            if (fuzzyRemoveIds.length > 0) {
+              const ph = fuzzyRemoveIds.map(() => '?').join(',');
+              db.prepare(`UPDATE observations SET superseded_at = ?, superseded_by = 'auto-dedup-fuzzy' WHERE id IN (${ph})`)
+                .run(Date.now(), ...fuzzyRemoveIds);
+              debugLog('DEBUG', 'auto-maintain', `fuzzy auto-deduped ${fuzzyRemoveIds.length} near-identical observations`);
+            }
+          }
+        }
+
         // Mark maintenance as done (24h gate) — even though compression runs in background
         writeFileSync(maintainFile, JSON.stringify({ epoch: Date.now() }));
         // Weekly summary grouping runs in background to avoid blocking SessionStart

package/install.mjs

@@ -25,10 +25,115 @@ const MARKETPLACE_KEY = 'sdsrss';
 const PLUGIN_KEY = `claude-mem-lite@${MARKETPLACE_KEY}`;
 const NPM_INSTALL_CMD = 'npm install --omit=dev --no-audit --no-fund';
 
+import { createRequire } from 'module';
+
 import { RESOURCE_METADATA } from './install-metadata.mjs';
 import { scanPluginCacheHookPollution } from './plugin-cache-guard.mjs';
 import { SOURCE_FILES } from './source-files.mjs';
 
+/**
+ * Hook scripts that non-dev install must copy into ~/.claude-mem-lite/scripts/
+ * to keep settings.json hook commands resolvable. Single source of truth so
+ * adding a new PreToolUse/PostToolUse hook script can't drift from the install
+ * copy block (which previously hand-listed only 3 of these and silently
+ * dropped pre-tool-recall.js + pre-skill-bridge.js — every fresh install left
+ * settings.json pointing at non-existent files).
+ */
+export const HOOK_SCRIPT_FILES = [
+  'post-tool-use.sh',
+  'user-prompt-search.js',
+  'prompt-search-utils.mjs',
+  'pre-tool-recall.js',
+  'pre-skill-bridge.js',
+];
+
+export function copyHookScripts(srcDir, destDir) {
+  for (const name of HOOK_SCRIPT_FILES) {
+    const src = join(srcDir, name);
+    if (existsSync(src)) copyFileSync(src, join(destDir, name));
+  }
+}
+
+/**
+ * Move legacy `~/.claude-mem/claude-mem.db` (+ -wal/-shm sidecars) to
+ * timestamped `*.legacy-backup-<ms>` files inside `newDir`. The legacy DB
+ * carries v16 schema (schema_versions plural table); the new claude-mem-lite
+ * code expects v28 (schema_version singular + memory_session_id column) and
+ * MIGRATIONS[] has no v16→v28 bridge — so loading the legacy DB FATALs on
+ * first launch. Backing up rather than copying-as-current lets the new
+ * install create a fresh v28 DB while preserving legacy bytes for recovery.
+ *
+ * Returns: {action: 'noop'|'skip'|'backed-up', backupPath?}
+ *   - noop: no legacy DB found
+ *   - skip: working `claude-mem-lite.db` already exists in newDir
+ *   - backed-up: legacy files renamed to `<newDir>/claude-mem-lite.db.legacy-backup-<ts>` etc.
+ */
+export function migrateLegacyClaudeMemData(oldDir, newDir, opts = {}) {
+  const legacyDb = join(oldDir, 'claude-mem.db');
+  const targetDb = join(newDir, 'claude-mem-lite.db');
+  if (!existsSync(legacyDb)) return { action: 'noop' };
+  if (existsSync(targetDb)) return { action: 'skip' };
+
+  if (!existsSync(newDir)) mkdirSync(newDir, { recursive: true });
+  const ts = opts.now ?? Date.now();
+  const backupPath = join(newDir, `claude-mem-lite.db.legacy-backup-${ts}`);
+  renameSync(legacyDb, backupPath);
+  for (const ext of ['-wal', '-shm']) {
+    const src = legacyDb + ext;
+    if (existsSync(src)) renameSync(src, join(newDir, `claude-mem-lite.db${ext}.legacy-backup-${ts}`));
+  }
+  return { action: 'backed-up', backupPath };
+}
+
+/**
+ * Probe better-sqlite3's native binding by importing it from `installDir`'s
+ * node_modules and opening an in-memory DB. Returns {ok, error?}. `npm install`
+ * exits 0 even when the prebuilt .node binary mismatches the running Node ABI
+ * (e.g. NODE_MODULE_VERSION 137 on Node v24), so install must verify before
+ * declaring success — otherwise the next launch FATALs with "Could not locate
+ * the bindings file".
+ */
+export async function probeBetterSqlite3Binding(installDir) {
+  try {
+    const localRequire = createRequire(join(installDir, 'package.json'));
+    const Database = localRequire('better-sqlite3');
+    const db = new Database(':memory:');
+    db.close();
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+/**
+ * Verify better-sqlite3 binding works in `installDir`; if not, run
+ * `npm rebuild better-sqlite3` and re-probe. Returns
+ * { ok: true, action: 'verified' | 'rebuilt' } on success or
+ * { ok: false, error } if rebuild can't fix it. The `probe` and `rebuild`
+ * deps are injectable so this can be unit-tested without a real npm
+ * subprocess.
+ */
+export async function ensureBetterSqlite3Working(installDir, deps = {}) {
+  const probe = deps.probe || (() => probeBetterSqlite3Binding(installDir));
+  const rebuild = deps.rebuild || (async () => {
+    execSync('npm rebuild better-sqlite3', { cwd: installDir, stdio: 'pipe' });
+  });
+
+  const first = await probe();
+  if (first.ok) return { ok: true, action: 'verified' };
+
+  try {
+    await rebuild();
+  } catch (e) {
+    return { ok: false, error: `rebuild failed: ${e.message}` };
+  }
+
+  const second = await probe();
+  if (second.ok) return { ok: true, action: 'rebuilt' };
+
+  return { ok: false, error: second.error || first.error };
+}
+
 /**
  * Derive invocation_name from resource name when metadata doesn't provide one.
  * Rules:
@@ -265,13 +370,9 @@ async function install() {
         copyFileSync(src, dst);
       }
     }
-    // Copy scripts
-    const postToolSrc = join(PROJECT_DIR, 'scripts', 'post-tool-use.sh');
-    if (existsSync(postToolSrc)) copyFileSync(postToolSrc, join(scriptsDir, 'post-tool-use.sh'));
-    const promptSearchSrc = join(PROJECT_DIR, 'scripts', 'user-prompt-search.js');
-    if (existsSync(promptSearchSrc)) copyFileSync(promptSearchSrc, join(scriptsDir, 'user-prompt-search.js'));
-    const promptSearchUtilsSrc = join(PROJECT_DIR, 'scripts', 'prompt-search-utils.mjs');
-    if (existsSync(promptSearchUtilsSrc)) copyFileSync(promptSearchUtilsSrc, join(scriptsDir, 'prompt-search-utils.mjs'));
+    // Copy hook scripts (settings.json hook commands point at these — must
+    // stay in sync with HOOK_SCRIPT_FILES manifest)
+    copyHookScripts(join(PROJECT_DIR, 'scripts'), scriptsDir);
     // Ensure bash script is executable
     try { execFileSync('chmod', ['+x', join(scriptsDir, 'post-tool-use.sh')], { stdio: 'pipe' }); } catch {}
     // Copy commands directory
@@ -314,6 +415,18 @@ async function install() {
       fail('npm install failed: ' + e.message);
       process.exit(1);
     }
+    // npm install exits 0 even when the better-sqlite3 prebuilt .node binary
+    // mismatches the running Node ABI (e.g. NODE_MODULE_VERSION 137 on Node v24).
+    // Probe and auto-rebuild before declaring success — otherwise the next
+    // launch FATALs with "Could not locate the bindings file".
+    const verify = await ensureBetterSqlite3Working(INSTALL_DIR);
+    if (verify.ok) {
+      ok(`better-sqlite3: ${verify.action}`);
+    } else {
+      fail(`better-sqlite3 binding unusable after rebuild: ${verify.error}`);
+      log('Try manually: cd ' + INSTALL_DIR + ' && npm rebuild better-sqlite3 --build-from-source');
+      process.exit(1);
+    }
   }
 
   // 2b. Create global CLI symlink (claude-mem-lite command)
@@ -542,30 +655,19 @@ async function install() {
   writeSettings(settings);
   ok('Hooks configured (PreToolUse, PostToolUse, SessionStart, Stop, UserPromptSubmit)');
 
-  // 5. Migrate from old ~/.claude-mem/ if needed
-  if (existsSync(join(OLD_DATA_DIR, 'claude-mem.db')) && !existsSync(DB_PATH) && !existsSync(join(DATA_DIR, 'claude-mem.db'))) {
-    log('Detected old ~/.claude-mem/ directory, migrating to ~/.claude-mem-lite/...');
-    try {
-      if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
-      // Migrate database and WAL/SHM files (copy as claude-mem-lite.db)
-      const srcDb = join(OLD_DATA_DIR, 'claude-mem.db');
-      if (existsSync(srcDb)) copyFileSync(srcDb, DB_PATH);
-      for (const ext of ['-wal', '-shm']) {
-        const src = join(OLD_DATA_DIR, 'claude-mem.db' + ext);
-        if (existsSync(src)) copyFileSync(src, DB_PATH + ext);
-      }
-      // Migrate runtime directory
-      const oldRuntime = join(OLD_DATA_DIR, 'runtime');
-      const newRuntime = join(DATA_DIR, 'runtime');
-      if (existsSync(oldRuntime) && !existsSync(newRuntime)) {
-        cpSync(oldRuntime, newRuntime, { recursive: true });
-      }
-      ok('Data migrated from ~/.claude-mem/ → ~/.claude-mem-lite/');
-      log('Old ~/.claude-mem/ preserved (remove manually when ready)');
-    } catch (e) {
-      warn('Migration failed: ' + e.message);
-      log('You can copy manually: cp ~/.claude-mem/claude-mem.db ~/.claude-mem-lite/claude-mem-lite.db');
+  // 5. Legacy ~/.claude-mem/ → ~/.claude-mem-lite/ — back up, don't reuse.
+  // The legacy DB is schema v16 (schema_versions plural) and there's no
+  // bridge in MIGRATIONS[] to v28. Reusing it FATALs on first launch with
+  // "no such column: memory_session_id". Rename to a timestamped backup
+  // so the new install creates a fresh v28 DB.
+  try {
+    const r = migrateLegacyClaudeMemData(OLD_DATA_DIR, DATA_DIR);
+    if (r.action === 'backed-up') {
+      ok(`Legacy ~/.claude-mem/ DB backed up to ${r.backupPath}`);
+      log('New v28 DB will be created on first launch (legacy schema is incompatible).');
     }
+  } catch (e) {
+    warn('Legacy DB backup failed: ' + e.message);
   }
 
   // 5b. Rename claude-mem.db → claude-mem-lite.db in same directory

package/lib/stats-quality.mjs

@@ -5,6 +5,7 @@
 
 import { notLowSignalTitleClause } from '../scoring-sql.mjs';
 import { truncate } from '../format-utils.mjs';
+import { COMPRESSED_PENDING_PURGE } from '../utils.mjs';
 
 export function computeQualityStats(db, { project, days }) {
   const projectFilter = project ? 'AND project = ?' : '';
@@ -69,11 +70,22 @@ export function computeQualityStats(db, { project, days }) {
     LIMIT 5
   `).all(...baseParams);
 
-  return { windowRow, allTimeRow, typeRows, topLessons, project, days };
+  // Pending-purge backlog: compressed records waiting on the time-based purge gate.
+  // High ratio signals push/pull imbalance — auto-mark fires daily but purge needs
+  // age > 37d, so a sudden write surge inflates this until the cohort ages out.
+  const purgeRow = db.prepare(`
+    SELECT
+      SUM(CASE WHEN compressed_into IS NOT NULL AND compressed_into != 0 THEN 1 ELSE 0 END) as compressed,
+      SUM(CASE WHEN compressed_into = ${COMPRESSED_PENDING_PURGE} THEN 1 ELSE 0 END) as pending_purge
+    FROM observations
+    WHERE 1=1 ${projectFilter}
+  `).get(...baseParams);
+
+  return { windowRow, allTimeRow, typeRows, topLessons, purgeRow, project, days };
 }
 
 export function formatQualityReport(data) {
-  const { windowRow, allTimeRow, typeRows, topLessons, project, days } = data;
+  const { windowRow, allTimeRow, typeRows, topLessons, purgeRow, project, days } = data;
   const pct = (n, d) => d > 0 ? (100 * n / d).toFixed(1) : '0.0';
   const scope = project ? ` — ${project}` : '';
   const lines = [];
@@ -126,5 +138,16 @@ export function formatQualityReport(data) {
   lines.push(`    ${lessonStatus} Lesson rate ≥ 15%    → currently ${lessonPct}%  (gap ${lessonGap >= 0 ? '+' : ''}${lessonGap}pp)`);
   lines.push(`    ${noiseStatus} LOW_SIGNAL  ≤ 30%    → currently ${noisePct}%  (gap ${noiseGap >= 0 ? '+' : ''}${noiseGap}pp)`);
 
+  // Pending-purge ratio: fraction of compressed records still waiting deletion.
+  // Compressed-but-not-yet-purged is normal (37d retention floor); a high ratio
+  // either means a recent write surge OR that auto-maintain isn't running.
+  if (purgeRow && (purgeRow.compressed ?? 0) > 0) {
+    const purgePct = pct(purgeRow.pending_purge, purgeRow.compressed);
+    const purgeNum = parseFloat(purgePct);
+    const purgeGap = (purgeNum - 10).toFixed(1);
+    const purgeStatus = purgeNum <= 10 ? '✅' : (purgeNum <= 30 ? '🟡' : '🔴');
+    lines.push(`    ${purgeStatus} Pending purge ≤ 10%  → currently ${purgePct}% (${purgeRow.pending_purge}/${purgeRow.compressed})  (gap ${purgeGap >= 0 ? '+' : ''}${purgeGap}pp)${purgeNum > 10 ? ' — run: claude-mem-lite maintain execute --ops purge_stale --confirm' : ''}`);
+  }
+
   return lines.join('\n');
 }

package/mem-cli.mjs

@@ -412,6 +412,7 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
       if (queryVec) {
         const vecResults = vectorSearch(db, queryVec, {
           project: project || null,
+          type: type || null,
           vocabVersion: vocab.version,
           limit: VECTOR_SCAN_LIMIT,
         });
@@ -420,9 +421,14 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
           const rowMap = new Map(ftsRows.map(r => [r.id, r]));
           for (const vr of vecResults) {
             if (!rowMap.has(vr.id)) {
-              const obs = db.prepare('SELECT id, type, title, subtitle, created_at, created_at_epoch, lesson_learned, importance, branch, files_modified FROM observations WHERE id = ?').get(vr.id);
+              const obs = db.prepare('SELECT id, type, title, subtitle, project, created_at, created_at_epoch, lesson_learned, importance, branch, files_modified FROM observations WHERE id = ?').get(vr.id);
               if (obs) {
-                // Apply same filters as FTS5 query (aligned with MCP searchObservations)
+                // Apply same filters as FTS5 query (aligned with MCP searchObservations).
+                // Defense-in-depth: vectorSearch already filters type/project, but the
+                // post-filter keeps both gates symmetric so a future vectorSearch refactor
+                // can't silently leak across them (cf. #8162 paired-path lesson).
+                if (type && obs.type !== type) continue;
+                if (project && obs.project !== project) continue;
                 if (dateFrom && obs.created_at_epoch < dateFrom) continue;
                 if (dateTo && obs.created_at_epoch > dateTo) continue;
                 if (minImportance && (obs.importance ?? 1) < minImportance) continue;
@@ -440,9 +446,11 @@ function searchFts(db, ftsQuery, { type, project, limit, dateFrom, dateTo, minIm
             .slice(0, limit);
         } else if (vecResults.length > 0 && ftsRows.length === 0) {
           return vecResults
-            .map(vr => db.prepare('SELECT id, type, title, subtitle, created_at, created_at_epoch, lesson_learned, importance, branch FROM observations WHERE id = ?').get(vr.id))
+            .map(vr => db.prepare('SELECT id, type, title, subtitle, project, created_at, created_at_epoch, lesson_learned, importance, branch FROM observations WHERE id = ?').get(vr.id))
             .filter(obs => {
               if (!obs) return false;
+              if (type && obs.type !== type) return false;
+              if (project && obs.project !== project) return false;
               if (dateFrom && obs.created_at_epoch < dateFrom) return false;
               if (dateTo && obs.created_at_epoch > dateTo) return false;
               if (minImportance && (obs.importance ?? 1) < minImportance) return false;
@@ -2002,7 +2010,11 @@ Commands:
   timeline              Show observations around an anchor (shows recent if no anchor)
     --anchor ID         Center on this ID. Accepts N, #N, P#N, or S#N — P#/S# anchors
                         resolve to the nearest-in-time observation in the same project.
-    --query "text"      Find anchor by FTS5 search
+    --query "text"      Find anchor by FTS5 search. Ranks by BM25 × time-decay,
+                        so multi-term queries surface the BEST topical match
+                        (highest term coverage), not the most recent. For
+                        "recent activity around X", use 'recent' or
+                        'search "X" --sort time' instead.
     --before N          Show N before anchor (default 5)
     --after N           Show N after anchor (default 5)
     --project P         Filter by project

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.50.0",
+  "version": "2.52.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {

package/tool-schemas.mjs

@@ -318,11 +318,13 @@ export const tools = [
     name: 'mem_timeline',
     description:
       'Show observations before and after an anchor point (by ID or by FTS query).\n' +
+      'Query-anchor ranks by BM25 × time-decay → BEST topical match, not most recent.\n' +
       '\n' +
       'DO NOT use when:\n' +
       '  - You only want one record (use mem_get)\n' +
       '  - You have no anchor in mind and are just browsing (use mem_recent or mem_browse)\n' +
       '  - The sequence is obvious from commit history (use git log)\n' +
+      '  - You want "recent activity around X" (use mem_recent or mem_search sort="time")\n' +
       '\n' +
       'USE when:\n' +
       '  - Reconstructing what led up to / followed a specific bug or decision\n' +