claude-mem-lite 2.90.0 → 2.91.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.90.0",
+      "version": "2.91.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": "2.90.0",
+  "version": "2.91.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/cli.mjs

@@ -32,7 +32,10 @@ if (cmd === '--version' || cmd === '-v') {
   // No command: show CLI help if installed, install help if not
   const { existsSync } = await import('fs');
   const { join } = await import('path');
-  const dbPath = join(process.env.HOME || '', '.claude-mem-lite', 'claude-mem-lite.db');
+  // D#29: honor CLAUDE_MEM_DIR so the install-vs-CLI help routing is correct on
+  // relocated installs (matches schema.mjs DB_DIR; HOME fallback when env unset).
+  const dataDir = process.env.CLAUDE_MEM_DIR || join(process.env.HOME || '', '.claude-mem-lite');
+  const dbPath = join(dataDir, 'claude-mem-lite.db');
   if (existsSync(dbPath)) {
     const { run } = await import('./mem-cli.mjs');
     await run(['help']);

package/lib/maintain-core.mjs

@@ -120,7 +120,13 @@ export function mergeDuplicates(db, groups) {
   for (const group of groups) {
     if (!group || group.length < 2) continue;
     const [keepId, ...removeIds] = group;
-    for (const removeId of removeIds) merged += mergeStmt.run(keepId, removeId).changes;
+    for (const removeId of removeIds) {
+      // Skip self-merge: compressed_into=self hides the row from every
+      // compressed_into=0 view (recent/search/browse) — silent data loss from a
+      // typo like `--merge-ids 5:5`. Shared core, so this covers CLI + MCP.
+      if (removeId === keepId) continue;
+      merged += mergeStmt.run(keepId, removeId).changes;
+    }
   }
   return merged;
 }

package/lib/save-observation.mjs

@@ -40,6 +40,13 @@ export function saveObservation(db, params) {
   const project = params.project;
   const type = params.type || 'discovery';
   const content = params.content;
+  // Defensive single-source guard: never persist an empty/whitespace-only row.
+  // CLI's `!text` check and MCP's `z.string().min(1)` both let whitespace-only
+  // content through ("   " is length>=1 and truthy), creating junk observations
+  // with blank title/text. Reject here so both call sites are covered at once.
+  if (typeof content !== 'string' || content.trim().length === 0) {
+    throw new Error('mem_save: content is empty or whitespace-only');
+  }
   const rawTitle = params.title || content.slice(0, 100);
   const importance = params.importance ?? 2;
   const files = Array.isArray(params.files)

package/mem-cli.mjs

@@ -11,7 +11,7 @@ import { resolveProject } from './project-utils.mjs';
 import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
 import { getVocabulary, computeVector, _resetVocabCache } from './tfidf.mjs';
 import { autoBoostIfNeeded, reRankWithContext, markSuperseded } from './server-internals.mjs';
-import { searchObservationsHybrid, findFtsAnchor } from './search-engine.mjs';
+import { searchObservationsHybrid, findFtsAnchor, countSearchTotal } from './search-engine.mjs';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
@@ -26,7 +26,7 @@ import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
 import { parseIntFlag, isNumericToken } from './lib/cli-flags.mjs';
 import { auditMemdir, memdirPath } from './memdir.mjs';
 import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
-import { basename, join } from 'path';
+import { basename, join, sep } from 'path';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 
 // v2.41: shared CLI helpers extracted to cli/common.mjs. Keep this file as the
@@ -313,9 +313,24 @@ function cmdSearch(db, args) {
 
   // Trim to limit with offset. The engine always received perSourceOffset=0 and
   // over-fetched (see above), so the merged+reranked `results` start at row 0 and
-  // the offset is applied exactly ONCE here — for every mode. `total` is the full
-  // match count (capped at perSourceLimit), enabling the "N of M" display.
-  const total = results.length;
+  // the offset is applied exactly ONCE here — for every mode.
+  //
+  // `total` must be the TRUE population, independent of --limit/--offset (else the
+  // over-fetched candidate count grew with the page and broke the "N of M" /
+  // pagination contract). countSearchTotal mirrors each source's MATCH+filters;
+  // clamp to >= results.length so it never understates the rows actually shown
+  // (vector/concept augmentation can add obs rows beyond the FTS count).
+  const trueTotal = countSearchTotal(db, {
+    effectiveSource,
+    ftsQuery,
+    obsFtsQuery: orFallbackFired ? (relaxFtsQueryToOr(ftsQuery) || ftsQuery) : ftsQuery,
+    args: { project: project || null, obs_type: type || null, importance: minImportance || null, branch: branch || null },
+    project: project || null,
+    epochFrom: dateFrom,
+    epochTo: dateTo,
+    includeNoise,
+  });
+  const total = Math.max(trueTotal, results.length);
   const paged = results.slice(offset, offset + limit);
 
   if (paged.length === 0) {
@@ -924,7 +939,7 @@ function cmdTimeline(db, args) {
 function cmdSave(db, args) {
   const { positional, flags } = parseArgs(args);
   const text = positional.join(' ');
-  if (!text) {
+  if (!text.trim()) {
     fail('[mem] Usage: claude-mem-lite save "<text>" [--type T] [--title T] [--importance N] [--project P] [--files f1,f2] [--lesson T] [--closes-deferred 1,D#42]');
     return;
   }
@@ -2180,7 +2195,7 @@ function cmdRegistry(_memDb, args) {
       for (const r of results) {
         const badge = r.quality_tier === 'installed' ? '[✓]' : r.quality_tier === 'verified' ? '[★]' : '[○]';
         const categoryLabel = r.category ? ` [${r.category}]` : '';
-        const isManaged = r.local_path && r.local_path.includes('/.claude-mem-lite/managed/');
+        const isManaged = r.local_path && r.local_path.includes(join(DB_DIR, 'managed') + sep);
         const portablePath = isManaged && r.local_path.startsWith(home) ? '~' + r.local_path.slice(home.length) : (r.local_path || '');
         let howToUse;
         if (isManaged) {

package/package.json

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

package/registry-importer.mjs

@@ -8,9 +8,12 @@ import { debugLog, isPathConfined } from './utils.mjs';
 import { createHash } from 'crypto';
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { homedir } from 'os';
+import { DB_DIR } from './schema.mjs';
 
-const MANAGED_DIR = join(homedir(), '.claude-mem-lite', 'managed');
+// DATA artifact — managed resources live under the env-aware data dir (DB_DIR),
+// NOT a hardcoded homedir, so GitHub imports land where install.mjs + registry-scanner
+// read them under CLAUDE_MEM_DIR relocation (D#29). Equals homedir when the env is unset.
+const MANAGED_DIR = join(DB_DIR, 'managed');
 
 // ─── Tree Discovery ─────────────────────────────────────────────────────────
 

package/scripts/pre-skill-bridge.js

@@ -11,9 +11,15 @@ import { recordHookError } from '../lib/hook-telemetry.mjs';
 // CLAUDE_MEM_DIR mirrors pre-tool-recall.js — one env var sandboxes everything.
 const DATA_DIR = process.env.CLAUDE_MEM_DIR || join(homedir(), '.claude-mem-lite');
 const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
-const REGISTRY_DB_PATH = join(homedir(), '.claude-mem-lite', 'resource-registry.db');
-const MANAGED_BASE = join(homedir(), '.claude-mem-lite');
-const MANAGED_MARKER = '/.claude-mem-lite/managed/';
+// D#29: all data artifacts follow DATA_DIR (CLAUDE_MEM_DIR-aware), not a hardcoded
+// homedir — previously REGISTRY_DB_PATH/MANAGED_BASE/MARKER pinned homedir while line 12
+// honored the env, so relocated installs opened the wrong DB and the marker never matched
+// the relocated local_path. MANAGED_MARKER is only a coarse LIKE prefilter; the exact
+// MANAGED_BASE prefix check below is the real confinement gate (so LIKE-wildcard chars in
+// a relocated path can at worst over-admit to that gate, never bypass it).
+const REGISTRY_DB_PATH = join(DATA_DIR, 'resource-registry.db');
+const MANAGED_BASE = DATA_DIR;
+const MANAGED_MARKER = join(DATA_DIR, 'managed') + sep;
 
 try {
   // Skip if recursive hook

package/scripts/user-prompt-search.js

@@ -8,7 +8,7 @@ import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject,
 import { citeFactorClause } from '../scoring-sql.mjs';
 import { cjkPrecisionOk } from '../nlp.mjs';
 import { writeFileSync, readFileSync, existsSync, renameSync } from 'fs';
-import { join } from 'path';
+import { join, sep } from 'path';
 import Database from 'better-sqlite3';
 import { shouldSkip, computeEffectiveLen, detectIntent, shouldSkipByDedup, extractFiles, extractErrorSignature, DEDUP_STALE_MS, matchRegistrySkillName, detectMemOverride } from './prompt-search-utils.mjs';
 
@@ -439,10 +439,18 @@ function loadManagedSkillNames() {
     const rdb = new Database(REGISTRY_DB_PATH, { readonly: true });
     rdb.pragma('busy_timeout = 500');
     try {
+      // D#29: derive the managed marker from the env-aware data dir, not a hardcoded
+      // homedir literal — under CLAUDE_MEM_DIR relocation the stored local_path lives at
+      // DB_DIR/managed, so the old literal matched nothing and dropped every managed skill
+      // from injection. Coarse LIKE prefilter; resource names are re-validated downstream.
+      // D#29: derive the managed marker from the env-aware data dir, not a hardcoded
+      // homedir literal — under CLAUDE_MEM_DIR relocation the stored local_path lives at
+      // DB_DIR/managed, so the old literal matched nothing and dropped every managed skill
+      // from injection. Coarse LIKE prefilter; resource names are re-validated downstream.
       const rows = rdb.prepare(`
         SELECT name FROM resources
-        WHERE status = 'active' AND local_path LIKE '%/.claude-mem-lite/managed/%'
-      `).all();
+        WHERE status = 'active' AND local_path LIKE ?
+      `).all(`%${join(DB_DIR, 'managed') + sep}%`);
       return new Set(rows.map(r => r.name.toLowerCase()));
     } finally { rdb.close(); }
   } catch { return new Set(); }

package/search-engine.mjs

@@ -72,6 +72,110 @@ export function buildObsFtsParams({ now, projectBoost, ftsQuery, args, epochFrom
   return params;
 }
 
+// --- True match-count helpers (limit/offset-invariant search totals) ----------
+// The search path over-fetches per source — perSourceLimit = max(limit*3,
+// offset+limit+10) — and historically reported `total = results.length`. That made
+// "Found N of M" and the JSON `total` field grow with --limit/--offset, breaking
+// the documented pagination contract (a query's population must not change when you
+// page through it). These COUNT(*) helpers mirror each source's MATCH + filters
+// exactly, so `total` reflects the real population independent of paging. Shared by
+// CLI and MCP per the paired-path single-source-of-truth rule (#8217).
+//
+// Known approximation: post-SQL filters that DROP rows after the query (CJK
+// precision gate on prompts, --tier on obs) are not reflected here, so those niche
+// queries may overcount. Callers clamp total to >= page size, so it never
+// understates the rows actually shown.
+export function countObsFtsMatches(db, { ftsQuery, args = {}, epochFrom = null, epochTo = null, includeNoise = false }) {
+  if (!ftsQuery) return 0;
+  const lowSignalClause = includeNoise ? '' : `AND ${notLowSignalTitleClause('o')}`;
+  try {
+    const row = db.prepare(`
+      SELECT COUNT(*) as c
+      FROM observations_fts
+      JOIN observations o ON observations_fts.rowid = o.id
+      WHERE observations_fts MATCH ?
+        AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
+        AND (? IS NULL OR o.project = ?)
+        AND (? IS NULL OR o.type = ?)
+        AND (? IS NULL OR o.created_at_epoch >= ?)
+        AND (? IS NULL OR o.created_at_epoch <= ?)
+        AND (? IS NULL OR COALESCE(o.importance, 1) >= ?)
+        AND (? IS NULL OR o.branch = ?)
+        ${lowSignalClause}
+    `).get(
+      ftsQuery,
+      args.project ?? null, args.project ?? null,
+      args.obs_type ?? null, args.obs_type ?? null,
+      epochFrom, epochFrom,
+      epochTo, epochTo,
+      args.importance ?? null, args.importance ?? null,
+      args.branch ?? null, args.branch ?? null,
+    );
+    return row?.c ?? 0;
+  } catch { return 0; }
+}
+
+export function countSessionFtsMatches(db, { ftsQuery, project = null, epochFrom = null, epochTo = null }) {
+  if (!ftsQuery) return 0;
+  try {
+    const wheres = ['session_summaries_fts MATCH ?'];
+    const params = [ftsQuery];
+    if (project) { wheres.push('s.project = ?'); params.push(project); }
+    if (epochFrom) { wheres.push('s.created_at_epoch >= ?'); params.push(epochFrom); }
+    if (epochTo) { wheres.push('s.created_at_epoch <= ?'); params.push(epochTo); }
+    const row = db.prepare(`
+      SELECT COUNT(*) as c
+      FROM session_summaries_fts
+      JOIN session_summaries s ON session_summaries_fts.rowid = s.id
+      WHERE ${wheres.join(' AND ')}
+    `).get(...params);
+    return row?.c ?? 0;
+  } catch { return 0; }
+}
+
+export function countPromptFtsMatches(db, { ftsQuery, project = null, epochFrom = null, epochTo = null }) {
+  if (!ftsQuery) return 0;
+  try {
+    const wheres = ['user_prompts_fts MATCH ?', "p.prompt_text NOT LIKE '<task-notification>%'"];
+    const params = [ftsQuery];
+    if (project) { wheres.push('s.project = ?'); params.push(project); }
+    if (epochFrom) { wheres.push('p.created_at_epoch >= ?'); params.push(epochFrom); }
+    if (epochTo) { wheres.push('p.created_at_epoch <= ?'); params.push(epochTo); }
+    const row = db.prepare(`
+      SELECT COUNT(*) as c
+      FROM user_prompts_fts
+      JOIN user_prompts p ON user_prompts_fts.rowid = p.id
+      JOIN sdk_sessions s ON p.content_session_id = s.content_session_id
+      WHERE ${wheres.join(' AND ')}
+    `).get(...params);
+    return row?.c ?? 0;
+  } catch { return 0; }
+}
+
+/**
+ * Sum true match counts across the sources that contribute to a cross-source (or
+ * source-restricted) search. `obsFtsQuery` lets callers pass the OR-relaxed query
+ * when obs AND→OR fallback fired (the displayed obs rows came from the OR query).
+ * @returns {number} population count, limit/offset-invariant
+ */
+export function countSearchTotal(db, {
+  effectiveSource = null, ftsQuery, obsFtsQuery = null,
+  args = {}, project = null, epochFrom = null, epochTo = null, includeNoise = false,
+}) {
+  let total = 0;
+  if (!effectiveSource || effectiveSource === 'observations') {
+    total += countObsFtsMatches(db, { ftsQuery: obsFtsQuery || ftsQuery, args, epochFrom, epochTo, includeNoise });
+  }
+  if (!effectiveSource || effectiveSource === 'sessions') {
+    total += countSessionFtsMatches(db, { ftsQuery, project, epochFrom, epochTo });
+  }
+  if (!effectiveSource || effectiveSource === 'prompts') {
+    total += countPromptFtsMatches(db, { ftsQuery, project, epochFrom, epochTo });
+  }
+  return total;
+}
+
 export function ftsRowToResult(r, { scoreMultiplier, snippet } = {}) {
   return {
     source: 'obs', id: r.id, type: r.type, title: r.title, subtitle: r.subtitle,

package/server.mjs

@@ -8,9 +8,9 @@ import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { truncate, typeIcon, sanitizeFtsQuery, relaxFtsQueryToOr, inferProject, scrubSecrets, cjkBigrams, fmtDate, debugLog, debugCatch, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS, isPathConfined, notLowSignalTitleClause } from './utils.mjs';
 import { extractCjkLikePatterns, cjkPrecisionOk } from './nlp.mjs';
 import { resolveProject as _resolveProjectShared } from './project-utils.mjs';
-import { ensureDb, DB_PATH, REGISTRY_DB_PATH } from './schema.mjs';
+import { ensureDb, DB_PATH, DB_DIR, REGISTRY_DB_PATH } from './schema.mjs';
 import { reRankWithContext, markSuperseded, autoBoostIfNeeded, runIdleCleanup, buildServerInstructions } from './server-internals.mjs';
-import { searchObservationsHybrid, findFtsAnchor } from './search-engine.mjs';
+import { searchObservationsHybrid, findFtsAnchor, countSearchTotal } from './search-engine.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
@@ -30,7 +30,7 @@ function descriptionOf(name) {
   return d;
 }
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
-import { basename, join } from 'path';
+import { basename, join, sep } from 'path';
 import { homedir } from 'os';
 import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
@@ -314,7 +314,7 @@ function searchPrompts(ctx) {
   return results;
 }
 
-function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, isCrossSource, orFallbackFired = false) {
+function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, orFallbackFired = false) {
   if (paginatedResults.length === 0) {
     const hint = [];
     if (args.query && !ftsQuery) {
@@ -332,7 +332,13 @@ function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, isCros
   }
 
   const lines = [];
-  const countLabel = isCrossSource && totalCount > paginatedResults.length
+  // "N of M" whenever the population exceeds the page — NOT gated on isCrossSource.
+  // totalCount is the true limit/offset-invariant population (countSearchTotal), so
+  // single-source searches (obs_type / type / importance filters) must surface it too.
+  // The old isCrossSource gate predated countSearchTotal: back then single-source
+  // totalCount was just results.length, so suppressing "of M" hid nothing. Now it hid
+  // the real total, diverging from the CLI (mem-cli.mjs has no such gate). (#8217)
+  const countLabel = totalCount > paginatedResults.length
     ? `${paginatedResults.length} of ${totalCount}`
     : `${paginatedResults.length}`;
   const hasMixed = paginatedResults.some(r => r.source === 'session' || r.source === 'prompt');
@@ -385,9 +391,15 @@ server.registerTool(
     const searchType = args.type;
     const currentProject = inferProject();
 
-    const isCrossSourceRaw = !searchType;
-    const perSourceLimit = isCrossSourceRaw ? Math.max(limit * 3, offset + limit + 10) : limit;
-    const perSourceOffset = isCrossSourceRaw ? 0 : offset;
+    // Over-fetch from offset 0 for EVERY mode, then apply `offset` exactly once at
+    // the merge slice below — identical to the CLI (mem-cli.mjs perSourceOffset=0).
+    // The old single-source branch (perSourceLimit=limit, perSourceOffset=offset)
+    // double-applied offset: it pushed offset into the per-source SQL AND re-sliced
+    // by offset at merge, so explicit `type=observations` paging overlapped (page 0
+    // == page 1) and gapped (oldest rows unreachable). It also fetched only `limit`
+    // rows — fewer than offset+limit — so there was nothing to page into. (#8217)
+    const perSourceLimit = Math.max(limit * 3, offset + limit + 10);
+    const perSourceOffset = 0;
 
     // Parse date bounds to epoch (with validation)
     // date_to with date-only format (YYYY-MM-DD) extends to end-of-day (23:59:59.999Z)
@@ -401,7 +413,7 @@ server.registerTool(
 
     // Early return when query was provided but sanitized to nothing (all FTS5 keywords/special chars)
     if (args.query && !ftsQuery && !epochFrom && !epochTo && !args.obs_type && !args.importance) {
-      return formatSearchOutput([], args, ftsQuery, 0, false);
+      return formatSearchOutput([], args, ftsQuery, 0);
     }
 
     // When obs_type is specified, implicitly restrict to observations only
@@ -502,11 +514,25 @@ server.registerTool(
     }
     // else 'relevance' keeps BM25 score order (already sorted)
 
-    const totalBeforePagination = results.length;
+    // `total` must be the TRUE population, invariant to limit/offset. In cross-source
+    // mode results is over-fetched (perSourceLimit scales with limit+offset), so
+    // results.length is NOT the population — count the real MATCH set instead. Clamp
+    // to >= results.length so vector/concept-augmented obs rows are never undercounted.
+    // (paired-path with mem-cli.mjs via shared countSearchTotal — #8217)
+    const trueTotal = countSearchTotal(db, {
+      effectiveSource: effectiveType || null,
+      ftsQuery,
+      obsFtsQuery: ctx.orFallbackFired === true ? (relaxFtsQueryToOr(ftsQuery) || ftsQuery) : ftsQuery,
+      args: { project: args.project || null, obs_type: args.obs_type || null, importance: args.importance || null, branch: args.branch || null },
+      project: args.project || null,
+      epochFrom, epochTo,
+      includeNoise: args.include_noise === true,
+    });
+    const totalBeforePagination = Math.max(trueTotal, results.length);
     // Always apply pagination — single-source results can exceed SQL LIMIT due to expansion (concept co-occurrence, PRF, vector search)
     const paginatedResults = (offset > 0 || results.length > limit) ? results.slice(offset, offset + limit) : results;
 
-    return formatSearchOutput(paginatedResults, args, ftsQuery, totalBeforePagination, isCrossSource, ctx.orFallbackFired === true);
+    return formatSearchOutput(paginatedResults, args, ftsQuery, totalBeforePagination, ctx.orFallbackFired === true);
   })
 );
 
@@ -1506,7 +1532,7 @@ server.registerTool(
       const lines = results.map(r => {
         const qualityBadge = r.quality_tier === 'installed' ? '[✓]' : r.quality_tier === 'verified' ? '[★]' : '[○]';
         const categoryLabel = r.category ? ` [${r.category}]` : '';
-        const isManaged = r.local_path && r.local_path.includes('/.claude-mem-lite/managed/');
+        const isManaged = r.local_path && r.local_path.includes(join(DB_DIR, 'managed') + sep);
         const portablePath = isManaged ? toPortable(r.local_path) : '';
         let howToUse;
         if (isManaged) {
@@ -1651,7 +1677,9 @@ server.registerTool(
       if (!row.local_path) {
         return { content: [{ type: 'text', text: `No local_path for ${args.name}` }], isError: true };
       }
-      const enrichBase = join(homedir(), '.claude-mem-lite');
+      // Confine to the env-aware data dir (managed/ relocates with CLAUDE_MEM_DIR, D#29);
+      // === homedir when the env is unset, so non-relocated confinement is unchanged.
+      const enrichBase = DB_DIR;
       if (!isPathConfined(row.local_path, enrichBase)) {
         return { content: [{ type: 'text', text: `Access denied: path outside managed directory` }], isError: true };
       }
@@ -1719,8 +1747,10 @@ server.registerTool(
       }
     }
 
-    // 4. Path confinement check — prevent reading arbitrary files via crafted local_path
-    const managedBase = join(homedir(), '.claude-mem-lite');
+    // 4. Path confinement check — prevent reading arbitrary files via crafted local_path.
+    // Base is the env-aware data dir (D#29): managed/ relocates with CLAUDE_MEM_DIR and
+    // equals homedir when unset, so this does not weaken the non-relocated confinement.
+    const managedBase = DB_DIR;
     if (skillPath && !isPathConfined(skillPath, managedBase)) {
       return { content: [{ type: 'text', text: `Access denied: path "${skillPath}" is outside managed directory` }], isError: true };
     }