claude-mem-lite 3.14.0 → 3.16.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.14.0",
+      "version": "3.16.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.14.0",
+  "version": "3.16.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/README.md

@@ -299,10 +299,15 @@ surface — reach them through the CLI column in the second table.
 
 ### Invited Memory (v2.32+)
 
-Opt-in mechanism that installs a single sentinel-wrapped line into the project's
-memdir (`~/.claude/projects/<encoded>/memory/MEMORY.md`) so Claude Code loads
-the plugin's MCP-tool triggers as **user-memory** — a higher instruction-following
-authority than MCP server instructions (which are framed as tool metadata).
+Opt-in mechanism that installs a slug-scoped managed block into the project's
+own `CLAUDE.md` (plus an on-demand detail doc under `.claude/`) so Claude Code
+loads the plugin's MCP-tool triggers as **project instructions** — a higher
+instruction-following authority than MCP server instructions (which are framed
+as tool metadata). Claude Code loads `CLAUDE.md` and the memdir `MEMORY.md` at
+equal weight, so steering lives in `CLAUDE.md` (the canonical home for project
+instructions) rather than polluting `MEMORY.md`, which is reserved for the user's
+own memories. The pre-v3.13 scheme wrote into `MEMORY.md`; it is migrated away
+automatically on the next SessionStart.
 
 ```bash
 claude-mem-lite adopt              # install for current project
@@ -317,30 +322,38 @@ claude-mem-lite unadopt            # remove sentinel + doc (runtime marker stays
 Slash commands `/adopt` and `/unadopt` wrap the same CLI.
 
 **What adoption changes:**
-- A `<!-- claude-mem-lite:begin v1 -->…<!-- claude-mem-lite:end -->` block is
-  added to `MEMORY.md` under a `## 插件契约` header, containing one ≤150-char
-  line pointing at `mem_recall` / `mem_save` with their key arguments.
-- A `plugin_claude_mem_lite.md` detail file is written (not auto-loaded; read
-  on demand when the MEMORY.md pointer surfaces in context).
+- A `<!-- claude-mem-lite:begin v1 -->…<!-- claude-mem-lite:end -->` managed
+  block is added to `<cwd>/CLAUDE.md` under its own
+  `## claude-mem-lite — persistent memory` header, containing a compact trigger
+  table pointing at `mem_recall` / `mem_save` / `mem_defer` with their key
+  arguments. The block is slug-scoped: only this region is managed; the rest of
+  your `CLAUDE.md` is preserved verbatim, and it coexists with other plugins'
+  blocks (e.g. `code-graph-mcp`) in the same file.
+- A `<cwd>/.claude/plugin_claude_mem_lite.md` detail file is written (not
+  auto-loaded; read on demand when the `CLAUDE.md` block points to it). The
+  block auto-refreshes when the shipped content drifts (version bump or template
+  change), unless `CLAUDE_MEM_NO_TEMPLATE_REFRESH=1`.
 - Post-adopt the conservative hook layer auto-trims: MCP server instructions
   drop the `WHEN TO USE` section, SessionStart injection drops the `File Lessons`
   / `Key Context` sections. `#ID` references and the `Recent` table still fire
   so `mem_get` remains reachable.
 
 **When does it take effect?**
-- The MEMORY.md sentinel and the hook-layer trim (`File Lessons` / `Key Context` /
-  lesson suffix) apply on the **next SessionStart** (any new Claude Code session
-  in the adopted project).
+- The `CLAUDE.md` managed block and the hook-layer trim (`File Lessons` /
+  `Key Context` / lesson suffix) apply on the **next SessionStart** (any new
+  Claude Code session in the adopted project).
 - The MCP server instructions are built once at server boot and MCP has no
   "push" protocol — the `WHEN TO USE` / `Decision rules` trim only applies
   after Claude Code restarts and re-spawns the mem-lite MCP server. A single
   `/exit` + fresh session is enough. Same caveat applies to `unadopt`.
 
 **Safety:**
-- Hash-guarded: editing the sentinel body yourself blocks automatic rewrites
-  unless you pass `--force`.
-- Budget-gated: refuses to insert when MEMORY.md is already >180 lines, so
-  Claude Code's 200-line MEMORY.md cap won't truncate the block.
+- Hash-guarded: editing the managed-block body yourself blocks automatic
+  rewrites unless you pass `--force`.
+- Slug-scoped & dedup-guarded: only the `claude-mem-lite:begin…end` region is
+  ever rewritten, and duplicate / CRLF-orphaned copies are collapsed to one.
+  Unlike the legacy `MEMORY.md` scheme there is no line-budget gate — `CLAUDE.md`
+  has no truncation cap.
 - **Auto-adopt fires on the first SessionStart per project for any install
   path (v2.82.1+).** Per-project opt-out: `claude-mem-lite adopt --disable`
   (writes a durable `<memdir>/.mem-no-auto-adopt` sentinel that survives marker

package/adopt-cli.mjs

@@ -13,9 +13,9 @@
 // it is redefined as a legacy-cleanup sweep (strip old memory-dir sentinels across
 // every memdir). New-scheme adoption happens per-project on SessionStart (cwd known).
 
-import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
+import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync, unlinkSync, readFileSync } from 'fs';
 import { homedir } from 'os';
-import { join } from 'path';
+import { join, isAbsolute } from 'path';
 import {
   memdirPath, removePluginSection, removePluginDoc,
   isAdopted as memdirIsAdopted, hasPluginState,
@@ -54,6 +54,25 @@ function listAllMemdirs() {
   return out;
 }
 
+function claudeConfigPath() { return join(homedir(), '.claude.json'); }
+
+// Real adopted-project paths come from Claude Code's own ~/.claude.json `projects`
+// map (keys are absolute cwds Claude Code has opened). The memdir slug under
+// ~/.claude/projects/ is a LOSSY encoding that can't be decoded back to a path,
+// so this is the only source that lets `unadopt --all` reach scattered CLAUDE.md
+// managed blocks. Filtered to absolute, still-existing dirs; claudeMdIsAdopted()
+// then gates which actually carry our block. Caveat: a project Claude Code never
+// recorded is invisible here and needs a per-project `unadopt`.
+function listKnownProjectDirs() {
+  const p = claudeConfigPath();
+  if (!existsSync(p)) return [];
+  try {
+    const cfg = JSON.parse(readFileSync(p, 'utf8'));
+    const projects = cfg && cfg.projects && typeof cfg.projects === 'object' ? Object.keys(cfg.projects) : [];
+    return projects.filter((d) => typeof d === 'string' && isAbsolute(d) && existsSync(d));
+  } catch { return []; }
+}
+
 function hasFlag(args, flag) { return Array.isArray(args) && args.includes(flag); }
 
 // ─── Per-project auto-adopt opt-out sentinel ─────────────────────────────────
@@ -290,6 +309,12 @@ function statusAll() {
   log(`[adopt --status] scanned ${dirs.length} memdir(s): ${legacy} with legacy sentinel (await migration), ${disabled} auto-adopt-disabled.`);
   if (legacy > 0) log('[adopt --status] run `claude-mem-lite adopt --all` to sweep legacy memory-dir sentinels now.');
 
+  const known = listKnownProjectDirs();
+  let adoptedCount = 0;
+  for (const dir of known) if (claudeMdIsAdopted(dir, PLUGIN_SLUG)) adoptedCount++;
+  log(`[adopt --status] known projects (~/.claude.json): ${known.length} scanned, ${adoptedCount} with a CLAUDE.md managed block.`);
+  if (adoptedCount > 0) log('[adopt --status] run `claude-mem-lite unadopt --all` to remove every CLAUDE.md block.');
+
   const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT ? 'set' : 'unset';
   const noAutoAdopt = process.env.MEM_NO_AUTO_ADOPT === '1' ? '1 (opt-out)' : 'unset';
   log('');
@@ -305,6 +330,54 @@ function statusAll() {
  * memory-dir cleanup across every memdir (CLAUDE.md blocks for other projects
  * can't be located from the lossy slug). Idempotent: exit code stays 0.
  */
+/**
+ * unadoptAll — `claude-mem-lite unadopt --all`. Removes the CLAUDE.md managed
+ * block + detail doc from EVERY adopted project Claude Code knows about (real
+ * paths from ~/.claude.json `projects`), then sweeps the legacy memory-dir
+ * residue across all memdirs. removeManaged is slug-scoped, so user content and
+ * other plugins' blocks are never touched. Honors --dry-run / --force.
+ *
+ * Unlike `adopt --all` (still a legacy-only sweep — adopting arbitrary projects
+ * is unsafe), unadopt is purely subtractive, so reaching every known project is
+ * both safe and what the uninstall hint promises.
+ */
+function unadoptAll(args) {
+  const force = hasFlag(args, '--force');
+  const dryRun = hasFlag(args, '--dry-run');
+
+  // 1. New scheme: scrub CLAUDE.md managed blocks across known project paths.
+  const projectDirs = listKnownProjectDirs();
+  let blocks = 0;
+  for (const dir of projectDirs) {
+    if (!claudeMdIsAdopted(dir, PLUGIN_SLUG)) continue;
+    if (dryRun) {
+      log(`[unadopt --all --dry-run] ${dir} → would-remove CLAUDE.md block + detail doc`);
+      blocks++;
+      continue;
+    }
+    const r = removeManaged(dir, PLUGIN_SLUG);
+    if (r.action === 'removed') { log(`[unadopt --all] ${dir} → removed`); blocks++; }
+  }
+
+  // 2. Legacy memory-dir cleanup across every memdir (foreign-content guarded).
+  const dirs = listAllMemdirs();
+  let legacy = 0;
+  for (const { memdir } of dirs) {
+    if (dryRun) {
+      if (memdirIsAdopted(memdir, PLUGIN_SLUG) && (hasPluginState(memdir, PLUGIN_SLUG) || force)) legacy++;
+      continue;
+    }
+    const r = removePluginSection(memdir, PLUGIN_SLUG, { force });
+    if (r.action === 'removed') { removePluginDoc(memdir, PLUGIN_SLUG); legacy++; }
+  }
+
+  log('');
+  log(`[unadopt --all] ${dryRun ? 'would remove' : 'removed'} ${blocks} CLAUDE.md block(s) across ${projectDirs.length} known project(s); ${legacy} legacy memory-dir sentinel(s) ${dryRun ? 'pending' : 'cleaned'}.`);
+  if (projectDirs.length === 0) {
+    log('[unadopt --all] no known projects found in ~/.claude.json — if a project was adopted but never opened in Claude Code, run `claude-mem-lite unadopt` from inside it.');
+  }
+}
+
 export function cmdUnadopt(args = []) {
   if (hasFlag(args, '--status')) return statusAll();
 
@@ -312,7 +385,7 @@ export function cmdUnadopt(args = []) {
   const dryRun = hasFlag(args, '--dry-run');
   const force = hasFlag(args, '--force');
 
-  if (all) return migrateAll(['--all', ...(force ? ['--force'] : []), ...(dryRun ? ['--dry-run'] : [])]);
+  if (all) return unadoptAll(args);
 
   const cwd = detectCwd();
   if (dryRun) {

package/adopt-content.mjs

@@ -3,16 +3,21 @@
 // <cwd>/.claude/plugin_claude_mem_lite.md detail doc. Kept separate from the
 // claudemd.mjs primitives so the strings are testable without side effects.
 //
-// Bumping CURRENT_SENTINEL_VERSION: pick the next vN. On the next SessionStart
-// needsRefresh() sees the version change and refreshes the block in place
-// (version bump = intended content change, so it overwrites rather than treating
-// the drift as a user edit). v1 = legacy memory-dir sentinel (now migrated away);
-// v2 = project-tree CLAUDE.md managed block.
+// CURRENT_SENTINEL_VERSION tags the managed block as `<!-- claude-mem-lite:begin
+// vN -->`. needsRefresh() only checks for *inequality* against the installed tag,
+// so any change triggers an in-place refresh (version change = intended content
+// change, overwritten rather than treated as a user edit) — the value need not be
+// monotonic. We deliberately use `v1` (not `v2`) so the version digit differs from
+// the sibling code-graph-mcp plugin's `<!-- code-graph-mcp:begin v2 -->` block in
+// the same CLAUDE.md; the slug already scopes the two independently (claudemd.mjs),
+// so this is a cosmetic distinguisher, not a functional one. The pre-v3.13 legacy
+// memory-dir MEMORY.md sentinel also carried `v1`, but it lives in a different file
+// and is migrated away (claudemd.migrateLegacyMemoryDir), so there is no collision.
 
 import { CLI_INVOKE } from './cli-path.mjs';
 
 export const PLUGIN_SLUG = 'claude-mem-lite';
-export const CURRENT_SENTINEL_VERSION = 'v2';
+export const CURRENT_SENTINEL_VERSION = 'v1';
 
 /**
  * The concise managed block injected into <cwd>/CLAUDE.md (between the
@@ -26,19 +31,19 @@ export function buildClaudeMdBlock() {
   // resolves to an absolute path that differs per install — it would make this
   // committed/refreshed block churn across machines). The robust CLI table lives
   // in the detail doc (.claude/, gitignored).
-  return `## claude-mem-lite — 持久记忆 (persistent memory)
+  return `## claude-mem-lite — persistent memory
 
-PreToolUse hooks 在 Read/Edit/Write 前已自动 \`mem_recall\` 过往教训。下面是值得你主动发起的调用：
+PreToolUse hooks already run \`mem_recall\` for past lessons before Read/Edit/Write. The calls worth making proactively:
 
-| 时机 | 调用 |
+| When | Call |
 |------|------|
-| Edit/Write 前 | hook 已自动 recall；若注入了 \`#NN\` 教训，下次产出用户可见文字时引用 \`#NN\`（引用=采纳反馈，未引用会衰减） |
-| 解决非平凡 bug 后 | \`mem_save(type="bugfix", lesson_learned="<根因+修法>", importance=2)\` |
-| 非显然架构决策后 | \`mem_save(type="decision", lesson_learned="<约束+取舍>")\` |
-| 推迟到下个会话 | \`mem_defer({title, priority:1|2|3, detail})\`；修好时给 \`mem_save\` 加 \`closes_deferred=[N]\` |
-| 查过往工作 / 历史 | \`mem_search "关键词"\` · \`mem_recent\` · \`mem_timeline\` |
+| Before Edit/Write | hook already recalled; if a \`#NN\` lesson was injected, cite \`#NN\` next time you produce user-visible text (citing = adopting the feedback; uncited lessons decay) |
+| After fixing a non-trivial bug | \`mem_save(type="bugfix", lesson_learned="<root cause + fix>", importance=2)\` |
+| After a non-obvious architecture decision | \`mem_save(type="decision", lesson_learned="<constraint + tradeoff>")\` |
+| Deferring to a future session | \`mem_defer({title, priority:1|2|3, detail})\`; when fixed, add \`closes_deferred=[N]\` to \`mem_save\` |
+| Looking up past work / history | \`mem_search "keywords"\` · \`mem_recent\` · \`mem_timeline\` |
 
-完整工具+CLI 表、citation/decay 规则、save 纪律见 → \`.claude/plugin_claude_mem_lite.md\``;
+Full tool + CLI tables, citation/decay rules, and save discipline → \`.claude/plugin_claude_mem_lite.md\``;
 }
 
 /**

package/claudemd.mjs

@@ -200,7 +200,18 @@ export function removeManaged(cwd, slug) {
       if (blockAtStart) raw = raw.replace(/^\s+/, '');
       action = 'removed';
     }
-    if (action === 'removed') atomicWrite(p, raw);
+    if (action === 'removed') {
+      // When the managed block was the ENTIRE file (adopt created CLAUDE.md
+      // because none existed), removing it leaves nothing but whitespace.
+      // Delete the now-empty file rather than writing a 0-byte CLAUDE.md, so
+      // unadopt fully restores the pre-adopt state — mirrors the emptied-.claude/
+      // cleanup below ("unadopt leaves no trace").
+      if (raw.trim() === '') {
+        try { unlinkSync(p); } catch { atomicWrite(p, raw); }
+      } else {
+        atomicWrite(p, raw);
+      }
+    }
   }
   const dp = detailDocPath(cwd, slug);
   if (existsSync(dp)) try { unlinkSync(dp); } catch { /* best-effort */ }

package/commands/adopt.md

@@ -16,7 +16,7 @@ force it immediately (e.g. after editing the block out by hand).
 
 ## What it writes
 
-1. **`<cwd>/CLAUDE.md`** — a concise `<!-- claude-mem-lite:begin v2 -->…<!-- :end -->`
+1. **`<cwd>/CLAUDE.md`** — a concise `<!-- claude-mem-lite:begin v1 -->…<!-- :end -->`
    managed block (trigger table → `mem_recall` / `mem_save` / `mem_defer`).
    Slug-scoped: only this block is managed; the rest of your `CLAUDE.md` is
    preserved verbatim. Auto-refreshes when the shipped content drifts.

package/commands/unadopt.md

@@ -1,6 +1,6 @@
 ---
 name: unadopt
-description: "Use when: user wants to remove the claude-mem-lite steering block from the current project (or sweep legacy memory-dir sentinels everywhere with --all). Removes the <cwd>/CLAUDE.md managed block + <cwd>/.claude/plugin_claude_mem_lite.md and cleans any legacy memory-dir residue. User content outside the sentinel is preserved. Benign no-op when not adopted."
+description: "Use when: user wants to remove the claude-mem-lite steering block from the current project (or from every project Claude Code knows about with --all). Removes the <cwd>/CLAUDE.md managed block + <cwd>/.claude/plugin_claude_mem_lite.md and cleans any legacy memory-dir residue. User content outside the sentinel is preserved. Benign no-op when not adopted."
 ---
 
 # /unadopt
@@ -24,9 +24,11 @@ project (slug-scoped — other plugins' blocks survive).
 
 - `--force` — also remove a legacy memory-dir block lacking a state sidecar
 - `--dry-run` — preview what would be removed; no writes
-- `--all` — legacy-cleanup sweep: strip the old memory-dir sentinel across every
-  project (CLAUDE.md blocks for other projects can't be located from the encoded
-  slug — `cd` into a project and run `/unadopt` there to remove its block).
+- `--all` — remove the CLAUDE.md managed block from every project in Claude
+  Code's known-project list (`~/.claude.json` `projects`), plus sweep any legacy
+  memory-dir sentinels. Slug-scoped, so user content and other plugins' blocks
+  survive. A project Claude Code never opened isn't listed — `cd` into it and run
+  `/unadopt` there. Pair with `--dry-run` to preview.
 - `--status` — read-only adoption probe (mirrors `/adopt --status`)
 
 ## Note: this does not stop auto-adopt

package/format-utils.mjs

@@ -61,6 +61,11 @@ export function fmtDate(iso) {
 export function fmtTime(iso) {
   if (!iso) return '';
   const d = new Date(iso);
+  // Guard against an unparseable timestamp (e.g. corrupt/imported created_at):
+  // a bare new Date('garbage') yields Invalid Date → getUTCHours() is NaN →
+  // "NaN:NaN" leaking into the SessionStart Recent table. Degrade to '' like the
+  // falsy-input case above.
+  if (Number.isNaN(d.getTime())) return '';
   return `${String(d.getUTCHours()).padStart(2, '0')}:${String(d.getUTCMinutes()).padStart(2, '0')}`;
 }
 

package/hook-context.mjs

@@ -27,6 +27,15 @@ function inferProjectDir() {
  * @param {string} project Project name to check velocity for
  * @returns {{tier1: number, tier2: number, tier3: number, sessWindow: number}} Time window durations in ms
  */
+// Sanitize a string for a GitHub-flavored-markdown table cell: a literal `|`
+// in a title (e.g. "grep | sort | uniq") would otherwise open phantom columns
+// and corrupt the <claude-mem-context> Recent table the model+user see every
+// SessionStart. Escape pipes and collapse any CR/LF/tab to a space so one obs
+// stays one row/cell.
+function mdCell(s) {
+  return String(s ?? '').replace(/[\r\n\t]+/g, ' ').replace(/\|/g, '\\|');
+}
+
 export function computeAdaptiveWindows(db, project) {
   const sevenDaysAgo = Date.now() - 7 * 86400000;
   const row = db.prepare(`
@@ -446,7 +455,7 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     obsLines.push('|----|------|---|-------|');
     for (const o of obsToShow) {
       const proj = o.project && o.project !== project ? ` (${o.project})` : '';
-      obsLines.push(`| #${o.id} | ${fmtTime(o.created_at)} | ${typeIcon(o.type)} | ${truncate(o.title || '(untitled)', 60)}${proj} |`);
+      obsLines.push(`| #${o.id} | ${fmtTime(o.created_at)} | ${typeIcon(o.type)} | ${mdCell(truncate(o.title || '(untitled)', 60) + proj)} |`);
     }
   }
 

package/hook-memory.mjs

@@ -16,8 +16,23 @@ const MEMORY_TYPE_BOOST = { decision: 1.5, discovery: 1.3, bugfix: 1.1, feature:
 // Adaptive BM25 thresholds — scale with corpus size to filter noise.
 // Larger corpora produce more weak matches from common words.
 const BM25_THRESHOLD = { TINY: 0, SMALL: 1.5, MEDIUM: 2.5, LARGE: 3.5 };
-// OR fallback max token count — queries with 3+ tokens that fail AND are likely off-topic
-const OR_FALLBACK_MAX_TOKENS = 2;
+// OR fallback max token count — when an AND query returns nothing, retry as OR
+// only if the query has at most this many significant terms. Natural-language
+// user prompts ("how did we fix the parser null deref bug?") almost always
+// exceed this after synonym expansion, so the old hard 2 silently denied them
+// the OR rescue and the UPS injection path returned 0 results for real prompts
+// (semantic-keyed recall measured at 26%, #8255; 0/11 on a realistic NL corpus).
+// Precision for OR results is already enforced downstream by three independent
+// gates — the 0.4x OR penalty, the adaptive BM25 threshold, and the 40%
+// term-coverage filter (v27) — so the token gate is a redundant, overly-strict
+// fourth guard predating term-coverage. Default raised to 8 (covers typical NL
+// prompts); env override `MEM_OR_FALLBACK_MAX_TOKENS` ∈ [0, 50], invalid → 8.
+function getOrFallbackMaxTokens() {
+  const raw = process.env.MEM_OR_FALLBACK_MAX_TOKENS;
+  if (raw === undefined || raw === '') return 8;
+  const n = parseInt(raw, 10);
+  return Number.isInteger(n) && n >= 0 && n <= 50 ? n : 8;
+}
 
 // v27: term-coverage post-filter. Drops high-BM25 candidates whose visible
 // fields (title + lesson_learned) cover <N% of the query's significant terms.
@@ -215,9 +230,10 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     // unconditionally; mirror that here. Noise is contained downstream (0.4x OR
     // penalty + BM25 threshold + term-coverage filter). queryIsCjkDominant (not
     // mere CJK presence) is the gate — see its definition at the function top.
+    const orFallbackMaxTokens = getOrFallbackMaxTokens();
     if (rows.length === 0) {
       const orQuery = relaxFtsQueryToOr(ftsQuery);
-      if (orQuery && (queryIsCjkDominant || queryTokenCount <= OR_FALLBACK_MAX_TOKENS)) {
+      if (orQuery && (queryIsCjkDominant || queryTokenCount <= orFallbackMaxTokens)) {
         try { rows = selectStmt.all(orQuery, project, cutoff); usedOrFallback = true; } catch {}
       }
     }
@@ -248,7 +264,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
       crossRows = crossStmt.all(ftsQuery, project, cutoff);
       if (crossRows.length === 0) {
         const orQuery = relaxFtsQueryToOr(ftsQuery);
-        if (orQuery && (queryIsCjkDominant || queryTokenCount <= OR_FALLBACK_MAX_TOKENS)) {
+        if (orQuery && (queryIsCjkDominant || queryTokenCount <= orFallbackMaxTokens)) {
           try { crossRows = crossStmt.all(orQuery, project, cutoff); crossUsedOr = true; } catch {}
         }
       }

package/install.mjs

@@ -1116,8 +1116,15 @@ async function uninstall() {
   cleanupMemHooksFromSettings(settings);
 
   // 2b. Uninstall does NOT auto-unadopt — an adopted project may be in active use
-  // by the user in other Claude Code sessions. Tell them the command instead.
-  log('Invited-memory: adopt state preserved. Run `claude-mem-lite unadopt --all` to remove sentinel sections.');
+  // in other Claude Code sessions, and adoption lives in EACH project's own
+  // CLAUDE.md. `unadopt --all` now strips every block across the projects Claude
+  // Code knows about (~/.claude.json), so point at it — but note the timing: a
+  // --purge run removes the CLI symlink, so this is best done BEFORE uninstall.
+  log('Invited-memory: project adoption left in place (each adopted project keeps its');
+  log('  CLAUDE.md managed block + .claude/plugin_claude_mem_lite.md). To remove it from');
+  log('  every known project, run `claude-mem-lite unadopt --all` — best done BEFORE');
+  log('  uninstall, while the CLI is still on PATH. A project Claude Code never opened');
+  log('  is not in the known list — run `claude-mem-lite unadopt` from inside it.');
 
   // 3. Clean plugin registry entries conservatively (avoid deleting other plugins
   // from the same marketplace publisher)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.14.0",
+  "version": "3.16.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",