claude-mem-lite 3.74.1 → 3.75.1

package/lib/resolve-data-dir.mjs

@@ -13,8 +13,57 @@
 //   - A relative path silently resolves against each process's cwd, scattering
 //     state across directories.
 // Falsy (unset/empty) is the only non-absolute value we treat as "use default".
-import { homedir } from 'node:os';
-import { join, isAbsolute } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { join, isAbsolute, resolve } from 'node:path';
+
+/**
+ * Test-run containment (audit 2026-08-22 P2-4).
+ *
+ * vitest.config.mjs clears CLAUDE_MEM_DIR for every worker, which stops a relocated
+ * dev DB from being read — but it cannot stop a test that never sets the var at all:
+ * that test simply resolves the DEFAULT, and the default is the maintainer's real
+ * `~/.claude-mem-lite`. It is not hypothetical. During the v3.73.0 release a test
+ * wrote a `rateLimited` marker into the live data dir, because the module computed
+ * its path at import time and the test's later env stub arrived too late.
+ *
+ * The guard rides the same channel as the leak: a subprocess that inherits
+ * `...process.env` (how e2e tests spawn hooks, and how the var goes missing in the
+ * first place) also inherits CLAUDE_MEM_TEST_GUARD, so the redirect follows it there.
+ * A subprocess given a curated env has to pass CLAUDE_MEM_DIR explicitly and is safe
+ * by construction.
+ *
+ * It REDIRECTS rather than throws, deliberately. Throwing was tried first and took 181
+ * of 289 test files down at collection: schema.mjs resolves the dir at IMPORT time, so
+ * every test that imports it — including the hundreds that then use `:memory:` and never
+ * touch a file — would have to opt out of a guard they never needed. "Imported the
+ * module" is not the failure; "wrote to the real directory" is, and a redirect makes
+ * that one impossible while leaving the import harmless.
+ *
+ * The redirect target is shared per run (CLAUDE_MEM_TEST_SANDBOX, set by
+ * tests/global-setup.mjs) so a parent and the subprocess it spawns still agree on one
+ * directory — the same reason the ambient env is inherited at all.
+ *
+ * Escape hatch: CLAUDE_MEM_TEST_GUARD=off, for a test that must exercise real default
+ * resolution. It should be rare and it should say why.
+ */
+function containInTests(dir) {
+  if (process.env.CLAUDE_MEM_TEST_GUARD !== '1') return dir;
+  // Block ONE directory: the real one. "Anywhere outside os.tmpdir()" was tried first
+  // and was wrong twice over — fixtures hardcode '/tmp' while os.tmpdir() follows
+  // $TMPDIR (relocated under $HOME by a sandboxed shell), and several suites keep their
+  // scratch DB inside the repo at tests/.tmp-*. Both are isolated; neither is the leak.
+  // The leak is always the same shape: nobody set CLAUDE_MEM_DIR, so the DEFAULT
+  // resolved, and the default is the developer's live database.
+  //
+  // Compared against the path captured by tests/global-setup.mjs BEFORE the suite
+  // relocated anything, not against homedir() — several suites deliberately run with
+  // HOME pointed at a fixture, and re-deriving the default here would redirect exactly
+  // those legitimate cases while missing the real dir once HOME moved.
+  const real = process.env.CLAUDE_MEM_TEST_REALDIR || join(homedir(), '.claude-mem-lite');
+  if (resolve(dir) !== resolve(real)) return dir;
+  const sandbox = process.env.CLAUDE_MEM_TEST_SANDBOX;
+  return sandbox && isAbsolute(sandbox) ? sandbox : join(resolve(tmpdir()), 'claude-mem-test-fallback');
+}
 
 /**
  * @param {string|undefined|null} raw  Typically process.env.CLAUDE_MEM_DIR.
@@ -23,7 +72,7 @@ import { join, isAbsolute } from 'node:path';
  */
 export function resolveDataDir(raw) {
   if (raw === undefined || raw === null || raw === '') {
-    return join(homedir(), '.claude-mem-lite');
+    return containInTests(join(homedir(), '.claude-mem-lite'));
   }
   if (typeof raw !== 'string' || raw === 'undefined' || raw === 'null' || !isAbsolute(raw)) {
     throw new Error(
@@ -31,5 +80,5 @@ export function resolveDataDir(raw) {
       `Leave it unset to use ~/.claude-mem-lite.`
     );
   }
-  return raw;
+  return containInTests(raw);
 }

package/lib/summary-extractor.mjs

@@ -9,7 +9,7 @@
 // with empty remaining_items. This extractor runs synchronously in
 // handleStop and gives a deterministic floor.
 
-import { readFileSync, existsSync } from 'fs';
+import { readTranscriptEntries } from './transcript-scan.mjs';
 
 const EN_HEADER = /^[\s●*>-]*(Done|Not\s+done|Failed|Uncertain)\s*[:：]\s*/im;
 const ZH_HEADER = /^[\s●*>-]*(剩下的?|剩余|还剩|未完成|下次(?:要做|做|继续)?|待做|未做)\s*[:：]?\s*/m;
@@ -27,14 +27,8 @@ const ZH_KEY_IS_NOTDONE = /剩下|剩余|还剩|未完成|下次|待做|未做/;
  * @returns {string|null}
  */
 export function extractTailAssistantText(transcriptPath) {
-  if (!transcriptPath || !existsSync(transcriptPath)) return null;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return null; }
   let last = null;
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     if (entry.type !== 'assistant' || !entry.message) continue;
     const content = entry.message.content;
     if (!Array.isArray(content)) continue;

package/lib/task-imperative.mjs

@@ -12,11 +12,18 @@ import { neutralizeContextDelimiters } from '../format-utils.mjs';
 // dropped.
 // Spec: docs/superpowers/specs/2026-06-29-task-imperative-memory-injection-design.md
 
+// The emitted line's fixed head. Exported because lib/citation-tracker.mjs matches on
+// it to meter this face: an extractor carrying its own copy of the framing is the exact
+// shape that silenced Go panics in v3.74.0 (trigger and filter were two lists that were
+// never the same list). One constant, both directions — change the framing and the
+// meter follows, or nothing does.
+export const TASK_IMPERATIVE_PREFIX = 'Memory — a past lesson applies to THIS task.';
+
 export function formatTaskImperative(lesson, id) {
   const body = neutralizeContextDelimiters(String(lesson || '').trim().replace(/\.$/, ''));
   if (!body) return '';
   const tag = (id === undefined || id === null || id === '') ? '' : ` (#${id})`;
-  return `Memory — a past lesson applies to THIS task. You must: ${body}.${tag}`;
+  return `${TASK_IMPERATIVE_PREFIX} You must: ${body}.${tag}`;
 }
 
 // Subagent-dispatch framing. Subagents are memory-blind (plugin hooks don't fire

package/lib/transcript-scan.mjs

@@ -0,0 +1,66 @@
+// One parse of a Claude Code transcript, shared by everything that scans it.
+//
+// Audit 2026-08-22 P2-8. handleStop asked the same .jsonl the same question eight
+// different ways — tail assistant text, citations, citations again with mainOnly,
+// injected-by-surface, cite-back signals, main-thread text, cite-recall, bugfix shape —
+// and every one of them did its own readFileSync + split('\n') + JSON.parse per line.
+// Measured on a real 5.7MB transcript: ~25ms per pass, so the repeated work is roughly
+// 175ms of a 5s Stop budget, and it scales linearly with a session that runs long.
+// Parsing is nearly all of it; iterating an already-parsed array of 2908 entries is
+// 0.1ms.
+//
+// This is a memo, not a rewrite: each scanner keeps its own per-entry logic exactly as
+// it was, and only stops re-reading and re-parsing the file to get at it.
+import { readFileSync, existsSync, statSync } from 'fs';
+
+// Retention cap. Parsed entries cost ~3.45× the file size in heap (measured, same
+// transcript: 5.7MB → 19.5MB). Holding that across a whole Stop is fine for the sessions
+// people actually have; holding it for a 50MB transcript is not, and a hook that gets
+// OOM-killed loses the session's work outright. Above the cap each caller parses on its
+// own exactly as before, so the worst case is today's behaviour rather than a new one.
+export const TRANSCRIPT_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+
+let cacheKey = '';
+let cacheEntries = null;
+
+/**
+ * Parsed transcript records, in file order, unparsable lines dropped.
+ *
+ * The cache key carries size and mtime: a transcript is append-only and Claude Code is
+ * still writing to it while the Stop hook runs, so a later caller in the same process
+ * must see the same fresh data it would have read for itself.
+ *
+ * @param {string|null|undefined} transcriptPath
+ * @returns {object[]} entries (empty array when the path is missing or unreadable)
+ */
+export function readTranscriptEntries(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return [];
+  let st;
+  try { st = statSync(transcriptPath); } catch { return []; }
+  const key = `${transcriptPath} ${st.size} ${st.mtimeMs}`;
+  if (key === cacheKey && cacheEntries) return cacheEntries;
+
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return []; }
+  const entries = [];
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    try { entries.push(JSON.parse(line)); } catch { /* a partially written tail line */ }
+  }
+  if (st.size <= TRANSCRIPT_CACHE_MAX_BYTES) {
+    cacheKey = key;
+    cacheEntries = entries;
+  } else {
+    // Drop whatever was held: an oversized transcript should not keep an older, smaller
+    // one alive in memory for the rest of the process either.
+    cacheKey = '';
+    cacheEntries = null;
+  }
+  return entries;
+}
+
+/** Test seam: forget the memo so a fixture rewritten within one mtime tick is re-read. */
+export function _resetTranscriptCache() {
+  cacheKey = '';
+  cacheEntries = null;
+}

package/lib/ups-query.mjs

@@ -0,0 +1,26 @@
+// lib/ups-query.mjs — the ONE query-cap definition for the UserPromptSubmit event.
+//
+// That event fires two hooks: scripts/user-prompt-search.js (the FYI block) and
+// `hook.mjs user-prompt` (the <memory-context> block). v3.75.0 capped the first and left
+// the second building an uncapped query from the raw prompt — the guard-on-one-path shape
+// this codebase pays for more than any other. Both faces now import from here, so the cap
+// cannot be present on one and absent on the other.
+//
+// The caps bound what is COMPUTED, not what is read. The stdin guards upstream
+// (MAX_UPS_PROMPT_BYTES 64KB on path A, MAX_HOOK_STDIN_BYTES 256KB on path B) cap the
+// input; sanitizeFtsQuery still costs 0.8ms on a normal prompt, 6.2ms on a 64KB ASCII one
+// and 31.8ms on a 64KB CJK one (extractCjkKeywords is O(len x dict) over an unsegmented
+// run), all of it before the model sees the turn. 2000 characters is a long prompt by any
+// measure, and past ~64 meaningful AND-joined terms an FTS5 query matches nothing anyway
+// and survives only through the OR fallback.
+//
+// An explicit `claude-mem-lite search` stays UNCAPPED — a person who types a long query
+// meant it. Only these two automatic surfaces pass the caps.
+import { sanitizeFtsQuery } from '../utils.mjs';
+
+export const UPS_QUERY_CAPS = { maxChars: 2000, maxTokens: 64 };
+
+/** The capped query builder every automatic prompt-time search path goes through. */
+export function upsFtsQuery(text) {
+  return sanitizeFtsQuery(text, UPS_QUERY_CAPS);
+}

package/mem-cli.mjs

@@ -17,10 +17,11 @@ import { resolveCliProject as cliProject } from './lib/cli-project.mjs';
 import { _resetVocabCache, vecTextForRow, vectorsEnabled } from './tfidf.mjs';
 import { reRankWithContext } from './search-scoring.mjs';
 import { searchObservationsHybrid } from './search-engine.mjs';
-import { fetchObsDetail, OBS_FIELDS, SESSION_DETAIL_FIELDS, supersededNotice } from './lib/get-core.mjs';
+import { fetchObsDetail, fetchPromptDetail, fetchEventDetail, OBS_FIELDS, SESSION_DETAIL_FIELDS, PROMPT_DETAIL_FIELDS, EVENT_DETAIL_FIELDS, supersededNotice } from './lib/get-core.mjs';
 import { collectBrowseTiers, getActiveMemorySessionId, BROWSE_TIERS, BROWSE_TIER_LABELS } from './lib/browse-core.mjs';
 import { deepSearch, resolveDeepMode, shouldEscalateToDeep, autoDeepLlmReady } from './deep-search.mjs';
-import { ensureRegistryDb, upsertResource, collectRegistryStats, listResourcesRanked, formatRegistryListLine } from './registry.mjs';
+import { ensureRegistryDb, collectRegistryStats, listResourcesRanked, formatRegistryListLine } from './registry.mjs';
+import { IMPORT_STRING_FIELDS, importResource, removeResource, reindexResources } from './lib/registry-core.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { computeFunnel, formatFunnel, computeSweep, formatSweep, DEFAULT_SWEEP_FLOORS, DEFAULT_SWEEP_MARGINS } from './registry-recommend.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
@@ -69,11 +70,12 @@ import { computeCitationFunnelTrend, computeSurfaceFunnel } from './lib/citation
 // the citation-stats face table lines up; the enum itself lives in
 // lib/citation-tracker.mjs (CITATION_SURFACES).
 const SURFACE_LABELS = {
-  pretool:      'PreToolUse recall  ',
-  ups:          'UserPromptSubmit   ',
-  error_recall: 'error-recall       ',
-  fyi:          'FYI (prompt-search)',
-  keyctx:       'Key Context        ',
+  pretool:        'PreToolUse recall  ',
+  ups:            'UserPromptSubmit   ',
+  error_recall:   'error-recall       ',
+  fyi:            'FYI (prompt-search)',
+  task_imperative: 'task-imperative   ',
+  keyctx:         'Key Context        ',
 };
 import { aggregateMetrics, readMetrics } from './lib/metrics.mjs';
 import {
@@ -579,34 +581,50 @@ function renderSessionRows(db, ids) {
   return { text: parts.join('\n\n'), count: rows.length };
 }
 
+// The CLI's established labels for the prompt/event detail faces. Sharing the FIELD SET
+// with MCP (P2-6) must not rename what users already grep for, so the columns that had a
+// label keep it; anything added later falls back to title-case.
+const CLI_DETAIL_LABELS = {
+  prompt_text: 'Text',
+  content_session_id: 'Session',
+  file_paths: 'Files',
+  git_sha: 'Git',
+};
+
+/** Label a column for the CLI's `Label: value` render style. */
+const cliFieldLabel = (f) =>
+  CLI_DETAIL_LABELS[f] || f[0].toUpperCase() + f.slice(1).replace(/_/g, ' ');
+
 function renderPromptRows(db, ids) {
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db.prepare(`SELECT * FROM user_prompts WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  const rows = fetchPromptDetail(db, ids);
   if (rows.length === 0) return null;
   const parts = [];
   for (const r of rows) {
     const lines = [`P#${r.id} ${fmtDateShort(r.created_at)}`];
-    if (r.prompt_text) lines.push(`Text: ${r.prompt_text}`);
-    if (r.content_session_id) lines.push(`Session: ${r.content_session_id}`);
+    // id and created_at are already in the header (same convention as the session face).
+    for (const f of PROMPT_DETAIL_FIELDS) {
+      if (f === 'id' || f === 'created_at') continue;
+      const val = r[f];
+      if (val === null || val === undefined || val === '') continue;
+      lines.push(`${cliFieldLabel(f)}: ${val}`);
+    }
     parts.push(lines.join('\n'));
   }
   return { text: parts.join('\n\n'), count: rows.length };
 }
 
 function renderEventRows(db, ids) {
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db.prepare(`SELECT * FROM events WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  const rows = fetchEventDetail(db, ids);   // derives created_at from created_at_epoch
   if (rows.length === 0) return null;
   const parts = [];
   for (const r of rows) {
-    // events store the distilled lesson in `body`; only *_epoch is available for the date.
-    const lines = [`E#${r.id} [${r.event_type}] ${r.created_at_epoch ? fmtDateShort(new Date(r.created_at_epoch).toISOString()) : ''}`];
-    if (r.title) lines.push(`Title: ${r.title}`);
-    if (r.body) lines.push(`Body: ${r.body}`);
-    if (r.project) lines.push(`Project: ${r.project}`);
-    if (r.importance !== null && r.importance !== undefined) lines.push(`Importance: ${r.importance}`);
-    if (r.file_paths) lines.push(`Files: ${r.file_paths}`);
-    if (r.git_sha) lines.push(`Git: ${r.git_sha}`);
+    const lines = [`E#${r.id} [${r.event_type}] ${r.created_at ? fmtDateShort(r.created_at) : ''}`];
+    for (const f of EVENT_DETAIL_FIELDS) {
+      if (f === 'id' || f === 'event_type' || f === 'created_at') continue;   // in the header
+      const val = r[f];
+      if (val === null || val === undefined || val === '') continue;
+      lines.push(`${cliFieldLabel(f)}: ${val}`);
+    }
     parts.push(lines.join('\n'));
   }
   return { text: parts.join('\n\n'), count: rows.length };
@@ -2339,24 +2357,12 @@ function cmdRegistry(_memDb, args) {
         fail(`[mem] Invalid --source "${flags.source}". Valid: preinstalled, user, github`);
         return;
       }
-      // Preserve provenance on a metadata-only re-import: default source to 'user' only for
-      // a genuinely NEW resource. Re-importing an existing github/preinstalled row without
-      // --source must not flip it to 'user' (which also mis-grants the user-source rank boost).
-      let source = flags.source;
-      if (!source) {
-        const existing = rdb.prepare('SELECT source FROM resources WHERE type = ? AND name = ?').get(resourceType, name);
-        source = existing ? existing.source : 'user';
-      }
-      const fields = { name, type: resourceType, status: 'active', source };
-      for (const f of ['repo-url', 'local-path', 'invocation-name', 'intent-tags', 'domain-tags', 'trigger-patterns', 'capability-summary', 'keywords', 'tech-stack', 'use-cases']) {
-        const camel = f.replace(/-([a-z])/g, (_, c) => '_' + c);
-        fields[camel] = flags[f] || '';
-      }
-      const id = upsertResource(rdb, fields);
-      // User-imported resources get 'installed' quality tier (user explicitly chose to add them)
-      if (id && !flags.source) {
-        rdb.prepare("UPDATE resources SET quality_tier = 'installed' WHERE id = ?").run(id);
-      }
+      // Provenance preservation + the 'installed' tier grant live in lib/registry-core.mjs,
+      // shared with the mem_registry MCP twin (audit 2026-08-22 P1-3). CLI flags are
+      // kebab-case; the core's field list is the canonical snake_case source.
+      const fields = {};
+      for (const f of IMPORT_STRING_FIELDS) fields[f] = flags[f.replace(/_/g, '-')] || '';
+      const { id } = importResource(rdb, { name, type: resourceType, source: flags.source, fields });
       out(`[mem] Imported: ${resourceType}:${name} (id=${id})`);
       if (!flags['capability-summary'] && !flags['use-cases']) {
         out('[mem] Tip: Add --capability-summary or --use-cases so the resource appears in searches.');
@@ -2371,17 +2377,16 @@ function cmdRegistry(_memDb, args) {
       const name = flags.name;
       const resourceType = flags['resource-type'];
       if (!name || !resourceType) { fail('[mem] Usage: claude-mem-lite registry remove --name N --resource-type skill|agent'); return; }
-      const result = rdb.prepare('DELETE FROM resources WHERE type = ? AND name = ?').run(resourceType, name);
-      out(result.changes > 0
+      const { removed } = removeResource(rdb, { name, type: resourceType });
+      out(removed
         ? `[mem] Removed: ${resourceType}:${name}`
         : `[mem] Not found: ${resourceType}:${name}`);
       return;
     }
 
     if (action === 'reindex') {
-      rdb.exec("INSERT INTO resources_fts(resources_fts) VALUES('rebuild')");
-      const count = rdb.prepare('SELECT COUNT(*) as c FROM resources WHERE status = ?').get('active');
-      out(`[mem] FTS5 reindexed. ${count.c} active resources.`);
+      const { activeCount } = reindexResources(rdb);
+      out(`[mem] FTS5 reindexed. ${activeCount} active resources.`);
       return;
     }
   } finally {
@@ -2802,6 +2807,9 @@ Commands:
 
   doctor                Environment diagnostics and benchmarks
     --benchmark         Run perf benchmark and emit JSON
+    --metrics           Summarize the recorded metrics window (CLAUDE_MEM_METRICS=1)
+    --session-audit     Audit session/episode state for orphans and drift
+    --json              Machine-readable output (plain doctor run)
 
   fts-check <check|rebuild>  FTS5 index check or rebuild
 
@@ -2837,6 +2845,7 @@ Commands:
     import              Import resource --name N --resource-type T [--repo-url U] [--local-path P] [--use-cases U]
     remove              Remove resource --name N --resource-type T
     reindex             Rebuild FTS5 index
+    recommend-stats     Shadow recommendation funnel [--days N] [--sweep] [--json]
 
   import-jsonl <file-or-dir>      Import Claude Code JSONL transcripts (cold-start backfill)
     --project P         Project name (default: inferred from cwd)

package/memdir.mjs

@@ -209,7 +209,11 @@ export function writePluginSection(memdir, { slug, version, contentLine, force =
     }
   }
 
-  const next = raw.replace(match[0], freshSection);
+  // Function form, NOT the string form: a string second argument has `$&` / `$1` /
+  // "$`" / `$'` interpreted, and freshSection carries caller-supplied contentLine — a
+  // `$&` there would expand to the whole matched sentinel block. Same fix claudemd.mjs
+  // took at its own replace (v3.40); this was the twin that kept the string form.
+  const next = raw.replace(match[0], () => freshSection);
   const changed = next !== raw;
   if (changed) atomicWrite(path, next);
   writeState(memdir, slug, { version, bodyHash: freshHash, writtenAt: new Date().toISOString() });

package/nlp.mjs

@@ -245,12 +245,26 @@ export const FTS_STOP_WORDS = new Set([...BASE_STOP_WORDS, ...CONTRACTION_FRAGME
 /**
  * Sanitize and expand a user query into a valid FTS5 query string.
  * Strips special characters, expands synonyms, and joins with AND/space.
+ *
+ * Unbounded by default — an explicit `search` from a human should search what they
+ * typed. The two caps exist for the AUTOMATIC surface (audit 2026-08-22 P2-13):
+ * UserPromptSubmit runs this on every prompt the user sends, with only a 64KB byte
+ * guard upstream, and cost grows with prompt length: 0.8ms on a normal prompt, 6.2ms
+ * on a 64KB ASCII one, 31.8ms on a 64KB CJK one (extractCjkKeywords is O(len x dict)
+ * over an unsegmented run). That is paid before the model sees the turn.
+ *
  * @param {string} query Raw user search query
+ * @param {object} [opts]
+ * @param {number} [opts.maxChars] Truncate the raw query first (bounds CJK segmentation,
+ *   which sees one huge token where ASCII sees many small ones).
+ * @param {number} [opts.maxTokens] Keep at most this many meaningful terms, applied
+ *   after stopword filtering and before expansion.
  * @returns {string|null} FTS5-safe query or null if empty
  */
-export function sanitizeFtsQuery(query) {
+export function sanitizeFtsQuery(query, opts = {}) {
   if (!query) return null;
-  const cleaned = query
+  const { maxChars = 0, maxTokens = 0 } = opts;
+  const cleaned = (maxChars > 0 ? String(query).slice(0, maxChars) : query)
     // Strip ASCII control chars / NUL FIRST. A NUL survives tokenization (it's not
     // \s), gets phrase-quoted by expandToken, and then terminates SQLite's C string
     // mid-phrase → FTS5 "unterminated string" throw, breaking the documented
@@ -293,6 +307,10 @@ export function sanitizeFtsQuery(query) {
   // Filter stop words (but keep all if filtering would empty the query)
   const filtered = tokens.filter(t => !FTS_STOP_WORDS.has(t.toLowerCase()));
   if (filtered.length > 0) tokens = filtered;
+  // Cap AFTER stopword filtering and BEFORE expansion: the terms kept are meaningful
+  // ones, and everything downstream (CJK segmentation, synonym expansion, bigrams) is
+  // per-token work that the cap therefore bounds too.
+  if (maxTokens > 0 && tokens.length > maxTokens) tokens = tokens.slice(0, maxTokens);
   // Split unsegmented CJK tokens into known vocabulary words using CJK_COMPOUNDS dictionary.
   // Uses broader dictionary than synonym-only extraction for better recall.
   // e.g. "这个函数是做什么的" → ["函数"] (not noisy bigrams)

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.74.1",
+  "version": "3.75.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.74.1",
+      "version": "3.75.1",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.26.0",
         "better-sqlite3": "^12.6.2",
@@ -21,6 +21,7 @@
         "eslint": "^10.0.0",
         "fast-check": "^4.5.3",
         "knip": "^6.12.1",
+        "picomatch": "^4.0.4",
         "vitest": "^4.0.18"
       },
       "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.74.1",
+  "version": "3.75.1",
   "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",
@@ -96,6 +96,7 @@
     "lib/save-observation.mjs",
     "lib/observation-write.mjs",
     "lib/recall-core.mjs",
+    "lib/registry-core.mjs",
     "lib/timeline-core.mjs",
     "lib/search-core.mjs",
     "lib/recent-core.mjs",
@@ -110,6 +111,9 @@
     "lib/save-enrich.mjs",
     "lib/persist-reminder.mjs",
     "lib/maintain-core.mjs",
+    "lib/fast-summary.mjs",
+    "lib/transcript-scan.mjs",
+    "lib/ups-query.mjs",
     "lib/dedup-constants.mjs",
     "lib/deferred-work.mjs",
     "lib/upgrade-banner.mjs",
@@ -166,6 +170,7 @@
     "scripts/pre-tool-recall.js",
     "scripts/post-tool-recall.js",
     "scripts/pre-skill-bridge.js",
+    "scripts/pre-agent-inject.sh",
     "scripts/pre-agent-inject.js",
     "scripts/prompt-search-utils.mjs",
     "scripts/hook-launcher.mjs",
@@ -194,6 +199,7 @@
     "eslint": "^10.0.0",
     "fast-check": "^4.5.3",
     "knip": "^6.12.1",
+    "picomatch": "^4.0.4",
     "vitest": "^4.0.18"
   }
 }

package/registry-recommend.mjs

@@ -1,8 +1,10 @@
 // Intent-based skill recommendation — Phase 1 (shadow).
 // See docs/superpowers/specs/2026-06-23-skill-recommendation-loop-design.md
 //
-// Phase-1 invariant: shadow AND live only LOG. Neither emits to stdout nor writes
-// invocations/recommend_count. Live injection is Phase 2. `off` skips all work.
+// Phase-1 invariant: the engine only LOGS. It never emits to stdout and never writes
+// invocations/recommend_count. Live injection is Phase 2 and does not exist yet, so
+// `live` resolves to shadow with a one-time warning (see UNIMPLEMENTED_MODES).
+// `off` skips all work.
 import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, appendFileSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { resolveDataDir } from './lib/resolve-data-dir.mjs';
@@ -10,13 +12,37 @@ import { searchResources, cjkIntentTokens } from './registry-retriever.mjs';
 
 import { DAY_MS } from './lib/time-constants.mjs';
 const VALID_MODES = new Set(['shadow', 'live', 'off']);
+// Phase 2 (live injection) was never built. `live` stayed in VALID_MODES and
+// getRecommendMode returned it verbatim, so setting it bought a user exactly
+// nothing and said nothing — the run behaved as shadow while the mode field in
+// every logged row claimed 'live'. Audit 2026-08-22 P2-5: an accepted value that
+// silently means something else is worse than an unsupported one. It still parses
+// (nobody's config breaks), it now resolves to what actually happens, and it says
+// so once per process.
+export const RECOMMEND_MODE_UNIMPLEMENTED = new Set(['live']);
+let warnedUnimplemented = false;
 
-/** Recommendation mode from env; default 'shadow', unknown → 'shadow'. */
-export function getRecommendMode() {
+/** The mode the environment ASKED for — 'live' included. For diagnostics (doctor). */
+export function getRequestedRecommendMode() {
   const raw = (process.env.CLAUDE_MEM_RECOMMEND_MODE || 'shadow').toLowerCase().trim();
   return VALID_MODES.has(raw) ? raw : 'shadow';
 }
 
+/** Recommendation mode actually in effect; default 'shadow', unknown → 'shadow'. */
+export function getRecommendMode() {
+  const requested = getRequestedRecommendMode();
+  if (!RECOMMEND_MODE_UNIMPLEMENTED.has(requested)) return requested;
+  if (!warnedUnimplemented && !process.env.MEM_QUIET_HOOKS) {
+    warnedUnimplemented = true;
+    // stderr, once: hook stdout is a parsed envelope and must not carry this.
+    process.stderr.write(
+      `[claude-mem-lite] CLAUDE_MEM_RECOMMEND_MODE=${requested} is not implemented `
+      + '(live injection is Phase 2); running in shadow mode — nothing is injected. '
+      + 'Set shadow or off to silence this.\n');
+  }
+  return 'shadow';
+}
+
 // Provisional gate thresholds — calibrated from shadow data before Phase 2 (spec §8).
 // relevance is raw bm25 (negative; more negative = better). Candidate must clear |floor|.
 export const RECO_BM25_FLOOR = -1.5;     // floor stays on raw bm25 (absolute topical relevance)

package/schema.mjs

@@ -280,7 +280,9 @@ const CORE_SCHEMA = `
   -- v45: per-INJECTION-FACE twin of citation_log. One row per
   -- (project, session, surface); the surface column is one of the
   -- CITATION_SURFACES enum in lib/citation-tracker.mjs
-  -- (pretool | ups | error_recall | fyi | keyctx).
+  -- (pretool | ups | error_recall | fyi | task_imperative | keyctx). The column is plain
+  -- TEXT with no CHECK: the JS enum is the gate (recordCitationSurfaces drops unknown
+  -- labels), which is why adding a face needs no migration.
   --
   -- session_id is the CLAUDE CODE session id, NOT the memory session id that
   -- keys citation_log. The two tables therefore do NOT join, on purpose. The

package/scoring-sql.mjs

@@ -80,15 +80,29 @@ export const TYPE_DECAY_CASE = `(
  * The old (pre-R2) table had bugfix=0.75 < change=0.8, inverted vs reality.
  * Applied as: BM25 × time_decay × TYPE_QUALITY × project_boost × importance
  */
+export const TYPE_QUALITY = {
+  decision: 1.5,
+  discovery: 1.3,
+  bugfix: 1.1,
+  feature: 1.0,
+  refactor: 0.6,
+  change: 0.5,
+};
+
+/** Multiplier for a type not in the table (legacy rows, manual saves). */
+export const TYPE_QUALITY_DEFAULT = 1.0;
+
+/**
+ * The SQL form, generated from TYPE_QUALITY rather than written beside it.
+ * The table used to exist three times — here, hook-context.mjs, hook-memory.mjs — with
+ * "aligned with scoring-sql.mjs (R2)" comments as the only thing keeping them equal
+ * (audit 2026-08-22, P2-10). Values happened to agree; the next re-weighting is what the
+ * copies were waiting for. Both JS consumers now import TYPE_QUALITY from here.
+ */
 export const TYPE_QUALITY_CASE = `(
   CASE o.type
-    WHEN 'decision'  THEN 1.5
-    WHEN 'discovery' THEN 1.3
-    WHEN 'bugfix'    THEN 1.1
-    WHEN 'feature'   THEN 1.0
-    WHEN 'refactor'  THEN 0.6
-    WHEN 'change'    THEN 0.5
-    ELSE 1.0
+${Object.entries(TYPE_QUALITY).map(([t, w]) => `    WHEN '${t}' THEN ${w.toFixed(1)}`).join('\n')}
+    ELSE ${TYPE_QUALITY_DEFAULT.toFixed(1)}
   END
 )`;