claude-mem-lite 3.35.0 → 3.35.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.35.0",
+      "version": "3.35.2",
       "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.35.0",
+  "version": "3.35.2",
   "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

@@ -33,8 +33,10 @@ if (cmd === '--version' || cmd === '-v') {
   const { existsSync } = await import('fs');
   const { join } = await import('path');
   // 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');
+  // relocated installs (matches schema.mjs DB_DIR via the shared resolver, which
+  // also fixes the HOME-unset relative-path fallback this branch used to have).
+  const { resolveDataDir } = await import('./lib/resolve-data-dir.mjs');
+  const dataDir = resolveDataDir(process.env.CLAUDE_MEM_DIR);
   const dbPath = join(dataDir, 'claude-mem-lite.db');
   if (existsSync(dbPath)) {
     const { run } = await import('./mem-cli.mjs');

package/hook-episode.mjs

@@ -136,6 +136,39 @@ export function createEpisode(sessionId, project) {
   };
 }
 
+/**
+ * Split an episode's entries by originating CC session so each concurrent
+ * session flushes as its own observation. Common path (single session, or all
+ * untagged/legacy entries) returns [episode] BY REFERENCE — behavior identical
+ * to pre-grouping. When >=2 sessions interleaved in one buffer, returns one
+ * sub-episode per session with its own entries + recomputed file union;
+ * filesRead (untagged bash reads-file) is inherited by every sub. Each sub
+ * resets savedId so it receives its own from its immediate-save (savedId is
+ * load-bearing: llm-episode upgrades the pre-saved obs by it).
+ * @param {object} episode
+ * @returns {object[]}
+ */
+export function planEpisodeFlush(episode) {
+  const groups = new Map();
+  for (const e of episode.entries) {
+    const key = e.ccSession ?? '__none__';
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(e);
+  }
+  if (groups.size <= 1) return [episode];
+  const subs = [];
+  for (const [, entries] of groups) {
+    subs.push({
+      ...episode,
+      entries,
+      files: [...new Set(entries.flatMap(e => e.files || []))],
+      filesRead: episode.filesRead,
+      savedId: undefined,
+    });
+  }
+  return subs;
+}
+
 /**
  * Add file paths to an episode's file tracking set (deduped).
  * @param {object} episode The episode to update

package/hook.mjs

@@ -31,7 +31,7 @@ import {
 import {
   readEpisodeRaw, episodeFile,
   acquireLock, releaseLock, readEpisode, writeEpisode,
-  createEpisode, addFileToEpisode,
+  createEpisode, addFileToEpisode, planEpisodeFlush,
   writePendingEntry, mergePendingEntries, episodeHasSignificantContent,
 } from './hook-episode.mjs';
 import { cleanupClaudeMdLegacyBlock, buildSessionContextLines } from './hook-context.mjs';
@@ -162,77 +162,104 @@ function flushEpisode(episode, hookEventName = 'PostToolUse') {
     episode.filesRead = episode.filesRead || [];
   }
 
-  const isSignificant = episodeHasSignificantContent(episode);
+  // Split by CC session so concurrent same-project sessions flush as separate
+  // observations. planEpisodeFlush returns [episode] BY REFERENCE for the common
+  // single-session (or all-legacy) case → flushEpisodeGroup(episode) is identical
+  // to pre-grouping. Two+ interleaved sessions each get their own sub-episode.
+  const subs = planEpisodeFlush(episode);
+  let anySignificant = false;
+  for (const sub of subs) {
+    const r = flushEpisodeGroup(sub);
+    if (r === 'writefail') {
+      // Single-group: preserve the original early return — buffer left un-unlinked
+      // for a later retry, no receipt. Multi-group: skip only the failed group and
+      // keep the rest. The asymmetry is safe: each group's immediate obs is persisted
+      // BEFORE its flush-file write, so re-flushing the whole buffer would re-emit
+      // already-saved groups as duplicate observations.
+      if (subs.length === 1) return;
+      continue;
+    }
+    if (r === 'significant') anySignificant = true;
+  }
+
+  // Aggregate receipt over the whole episode, gated exactly as before
+  // (isSignificant → anySignificant). v2.33.4: Stop rejects hookSpecificOutput.
+  if (anySignificant && RECEIPT_EVENTS.has(hookEventName)) {
+    try {
+      const entries = episode.entries || [];
+      const toolCounts = {};
+      for (const e of entries) toolCounts[e.tool] = (toolCounts[e.tool] || 0) + 1;
+      const toolSummary = Object.entries(toolCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([t, n]) => `${t}×${n}`)
+        .join(', ');
+      const lines = [`[mem] episode flushed: ${entries.length} entries (${toolSummary})`];
+      // v2.83: error→fix nudge lifted to lib/cite-back-hint.mjs::buildUnsavedBugfixHint
+      // so the wording (count + "Save now" verb) stays in sync with cite-back.
+      const bugfixHint = buildUnsavedBugfixHint(episode);
+      if (bugfixHint) lines.push(bugfixHint);
+      // v2.81: cite-back hint — fires when this episode edits a file that
+      // PreToolUse:Read/Edit nudged earlier in the same session. Precision
+      // signal (we know the file was warned about); orthogonal to the
+      // bugfix-shape nudge above and may co-fire.
+      const citeBack = loadCiteBackForEpisode(episode, RUNTIME_DIR);
+      if (citeBack) lines.push(citeBack);
+      // Trailing newline is REQUIRED: when this receipt flushes at SessionStart
+      // (leftover episode after /clear or /compact), the startup dashboard writes a
+      // second hookSpecificOutput object right after. Without the '\n' the two land
+      // back-to-back as `}{` on one line and Claude Code's line-based JSON parser
+      // drops both — losing the episode-flush / cite-back context exactly at the
+      // session boundary. Every other hookSpecificOutput write appends '\n'; this
+      // was the lone exception.
+      process.stdout.write(JSON.stringify({
+        suppressOutput: true,
+        hookSpecificOutput: {
+          hookEventName,
+          additionalContext: lines.join('\n'),
+        },
+      }) + '\n');
+    } catch { /* never block on receipt */ }
+  }
 
-  // Immediate save: create rule-based observation for instant visibility.
-  // LLM background worker will upgrade title/narrative/importance later.
+  // Remove episode buffer AFTER spawning background workers to prevent concurrent overwrites
+  try { unlinkSync(episodeFile()); } catch {}
+}
+
+// Save one episode-shaped object: immediate rule-based observation (if
+// significant) + flush file + llm-episode enrichment spawn. Extracted from
+// flushEpisode so each CC-session slice (from planEpisodeFlush) flushes
+// independently and carries its OWN savedId into its OWN flush file — the
+// llm-episode worker upgrades the pre-saved obs by that id. Returns
+// 'significant' | 'insignificant' | 'writefail'. CLAUDE_MEM_SKIP_EPISODE_LLM
+// suppresses the detached enrichment spawn (test determinism; sibling of
+// CLAUDE_MEM_SKIP_COMPRESS / _OPTIMIZE) — the synchronous immediate obs still lands.
+function flushEpisodeGroup(ep) {
+  const isSignificant = episodeHasSignificantContent(ep);
+
+  // Immediate save: rule-based observation for instant visibility; the LLM
+  // background worker upgrades title/narrative/importance later.
   if (isSignificant) {
     try {
-      const obs = buildImmediateObservation(episode);
-      const id = saveObservation(obs, episode.project, episode.sessionId);
-      if (id) episode.savedId = id;
+      const obs = buildImmediateObservation(ep);
+      const id = saveObservation(obs, ep.project, ep.sessionId);
+      if (id) ep.savedId = id;
     } catch (e) { debugCatch(e, 'flushEpisode-immediateSave'); }
   }
 
-  // Write episode to flush file, then remove buffer AFTER spawn to prevent race
   const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
   try {
-    writeFileSync(flushFile, JSON.stringify(episode));
+    writeFileSync(flushFile, JSON.stringify(ep));
   } catch {
-    return;
+    return 'writefail';
   }
 
-  if (isSignificant) {
+  if (isSignificant && !process.env.CLAUDE_MEM_SKIP_EPISODE_LLM) {
     spawnBackground('llm-episode', flushFile);
-
-    // v2.33.1: structured flush receipt so Claude sees what mem just captured
-    // and the legacy error→fix nudge consolidates here. PostToolUse JSON with
-    // hookSpecificOutput.additionalContext reliably renders across CC variants;
-    // the old plain-text stdout write was invisible on some variants.
-    // v2.33.4: Stop event rejects hookSpecificOutput entirely — skip receipt.
-    if (RECEIPT_EVENTS.has(hookEventName)) {
-      try {
-        const entries = episode.entries || [];
-        const toolCounts = {};
-        for (const e of entries) toolCounts[e.tool] = (toolCounts[e.tool] || 0) + 1;
-        const toolSummary = Object.entries(toolCounts)
-          .sort((a, b) => b[1] - a[1])
-          .slice(0, 3)
-          .map(([t, n]) => `${t}×${n}`)
-          .join(', ');
-        const lines = [`[mem] episode flushed: ${entries.length} entries (${toolSummary})`];
-        // v2.83: error→fix nudge lifted to lib/cite-back-hint.mjs::buildUnsavedBugfixHint
-        // so the wording (count + "Save now" verb) stays in sync with cite-back.
-        const bugfixHint = buildUnsavedBugfixHint(episode);
-        if (bugfixHint) lines.push(bugfixHint);
-        // v2.81: cite-back hint — fires when this episode edits a file that
-        // PreToolUse:Read/Edit nudged earlier in the same session. Precision
-        // signal (we know the file was warned about); orthogonal to the
-        // bugfix-shape nudge above and may co-fire.
-        const citeBack = loadCiteBackForEpisode(episode, RUNTIME_DIR);
-        if (citeBack) lines.push(citeBack);
-        // Trailing newline is REQUIRED: when this receipt flushes at SessionStart
-        // (leftover episode after /clear or /compact), the startup dashboard writes a
-        // second hookSpecificOutput object right after. Without the '\n' the two land
-        // back-to-back as `}{` on one line and Claude Code's line-based JSON parser
-        // drops both — losing the episode-flush / cite-back context exactly at the
-        // session boundary. Every other hookSpecificOutput write appends '\n'; this
-        // was the lone exception.
-        process.stdout.write(JSON.stringify({
-          suppressOutput: true,
-          hookSpecificOutput: {
-            hookEventName,
-            additionalContext: lines.join('\n'),
-          },
-        }) + '\n');
-      } catch { /* never block on receipt */ }
-    }
   } else {
     try { unlinkSync(flushFile); } catch {}
   }
-
-  // Remove episode buffer AFTER spawning background worker to prevent concurrent overwrites
-  try { unlinkSync(episodeFile()); } catch {}
+  return isSignificant ? 'significant' : 'insignificant';
 }
 
 // ─── PostToolUse Handler ────────────────────────────────────────────────────
@@ -294,6 +321,10 @@ async function handlePostToolUse() {
     isSignificant: EDIT_TOOLS.has(tool_name) ||
                    bashSig?.isSignificant || false,
     bashSig: bashSig || null,
+    // CC UUID from hook stdin — lets flushEpisode split a buffer shared by
+    // concurrent same-project sessions into per-session observations. Null for
+    // legacy/stdin-less invocations (→ single __none__ group = old behavior).
+    ccSession: hookData.session_id || null,
   };
 
   // Episode buffer management (locked to prevent TOCTOU race)

package/install.mjs

@@ -7,6 +7,7 @@ import { join, resolve, dirname, isAbsolute } from 'path';
 import { homedir, tmpdir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { createRequire } from 'node:module';
+import { resolveDataDir } from './lib/resolve-data-dir.mjs';
 
 const PROJECT_DIR = resolve(import.meta.dirname ?? dirname(fileURLToPath(import.meta.url)));
 const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
@@ -20,7 +21,7 @@ const DATA_DIR = join(homedir(), '.claude-mem-lite');
 // the runtime/data layer READS it (pre-fix: installer wrote homedir, runtime read
 // the relocated dir → preinstalled skills silently vanished, doctor read the wrong
 // DB). Equals DATA_DIR when CLAUDE_MEM_DIR is unset (the common case).
-const MEM_DATA_DIR = process.env.CLAUDE_MEM_DIR || DATA_DIR;
+const MEM_DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
 const DB_PATH = join(MEM_DATA_DIR, 'claude-mem-lite.db');
 const OLD_DATA_DIR = join(homedir(), '.claude-mem');
 

package/lib/resolve-data-dir.mjs

@@ -0,0 +1,35 @@
+// Single source of truth for resolving the CLAUDE_MEM_DIR data directory.
+// Zero runtime deps (node:path + node:os only) so hot-path hook scripts can
+// import it without pulling in better-sqlite3.
+//
+// The env var is a RELOCATION knob: unset → ~/.claude-mem-lite (the common,
+// non-relocated case); set → an absolute path on a larger/faster volume.
+// Anything else is a mistake we must reject LOUDLY rather than turn into a
+// stray directory:
+//   - The literal strings "undefined"/"null" arise when a caller interpolates
+//     a JS nullish value into a shell env string (e.g. `CLAUDE_MEM_DIR='${x}'`
+//     with x === undefined). They are truthy, so `env || default` accepts them
+//     and better-sqlite3 then creates a relative `undefined/` dir at cwd.
+//   - 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';
+
+/**
+ * @param {string|undefined|null} raw  Typically process.env.CLAUDE_MEM_DIR.
+ * @returns {string} An absolute data directory.
+ * @throws if `raw` is a non-empty, non-absolute value (incl. "undefined"/"null").
+ */
+export function resolveDataDir(raw) {
+  if (raw === undefined || raw === null || raw === '') {
+    return join(homedir(), '.claude-mem-lite');
+  }
+  if (typeof raw !== 'string' || raw === 'undefined' || raw === 'null' || !isAbsolute(raw)) {
+    throw new Error(
+      `CLAUDE_MEM_DIR must be an absolute path; got ${JSON.stringify(raw)}. ` +
+      `Leave it unset to use ~/.claude-mem-lite.`
+    );
+  }
+  return raw;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.35.0",
+  "version": "3.35.2",
   "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",
@@ -67,6 +67,7 @@
     "lib/id-routing.mjs",
     "lib/err-sampler.mjs",
     "lib/hook-telemetry.mjs",
+    "lib/resolve-data-dir.mjs",
     "lib/file-intel.mjs",
     "lib/reread-guard.mjs",
     "lib/metrics.mjs",

package/registry-recommend.mjs

@@ -5,7 +5,7 @@
 // invocations/recommend_count. Live injection is Phase 2. `off` skips all work.
 import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, appendFileSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
-import { homedir } from 'os';
+import { resolveDataDir } from './lib/resolve-data-dir.mjs';
 import { searchResources, cjkIntentTokens } from './registry-retriever.mjs';
 
 const VALID_MODES = new Set(['shadow', 'live', 'off']);
@@ -26,7 +26,7 @@ const RECO_COOLDOWN_MS = 300_000;        // 5 min, mirrors T4 SKILL_COOLDOWN_MS
 // DB_DIR formula) so tests sandbox via env without ESM-cache gymnastics, and prod reads
 // the same dir as the rest of the app.
 function recoRuntimeDir() {
-  return join(process.env.CLAUDE_MEM_DIR || join(homedir(), '.claude-mem-lite'), 'runtime');
+  return join(resolveDataDir(process.env.CLAUDE_MEM_DIR), 'runtime');
 }
 
 const TOKEN_SPLIT = /[^a-z0-9一-鿿]+/;

package/schema.mjs

@@ -7,10 +7,11 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, chmodSync } from 'fs';
 import { OBS_FTS_COLUMNS, debugCatch } from './utils.mjs';
+import { resolveDataDir } from './lib/resolve-data-dir.mjs';
 
 // DATA location — DB, managed resources, registry DB, runtime/. Honors
 // CLAUDE_MEM_DIR so users can relocate state to a larger/faster volume.
-export const DB_DIR = process.env.CLAUDE_MEM_DIR || join(homedir(), '.claude-mem-lite');
+export const DB_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
 export const DB_PATH = join(DB_DIR, 'claude-mem-lite.db');
 export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
 // CODE / install location — server.mjs, hook.mjs, cli.mjs, package.json live

package/scripts/hook-launcher.mjs

@@ -26,15 +26,20 @@
 
 import { existsSync, mkdirSync, writeFileSync, statSync, unlinkSync, readFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
+import { dirname, join, isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { homedir } from 'node:os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const INSTALL_DIR = join(__dirname, '..');
-const RUNTIME_DIR = process.env.CLAUDE_MEM_DIR
-  ? join(process.env.CLAUDE_MEM_DIR, 'runtime')
-  : join(homedir(), '.claude-mem-lite', 'runtime');
+// A bogus CLAUDE_MEM_DIR ("undefined"/"null"/relative from a mis-quoted env
+// interpolation) must degrade to the default here, not become a stray dir. The
+// launcher's pure-node charter (above) forbids importing lib/resolve-data-dir.mjs,
+// and its fail-open duty forbids throwing, so mirror that guard inline + lenient:
+// non-absolute → default. Data-writing paths import that module and throw instead.
+const MEM_DIR = process.env.CLAUDE_MEM_DIR;
+const DATA_DIR = MEM_DIR && isAbsolute(MEM_DIR) ? MEM_DIR : join(homedir(), '.claude-mem-lite');
+const RUNTIME_DIR = join(DATA_DIR, 'runtime');
 const HEAL_MARKER = join(RUNTIME_DIR, 'hook-launcher-lastheal');
 const HEAL_COOLDOWN_MS = 6 * 60 * 60 * 1000;
 // Observable breakage state: written when the launcher degrades a broken install

package/scripts/post-tool-recall.js

@@ -15,11 +15,11 @@
 
 import { existsSync, readFileSync } from 'fs';
 import { basename, join } from 'path';
-import { homedir } from 'os';
+import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
 
 const SALIENCE_BIND = process.env.CLAUDE_MEM_SALIENCE === 'bind';
 
-const DATA_DIR = process.env.CLAUDE_MEM_DIR || join(homedir(), '.claude-mem-lite');
+const DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
 const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
 const LEGACY_COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
 

package/scripts/pre-skill-bridge.js

@@ -7,9 +7,10 @@ import { existsSync, readFileSync } from 'fs';
 import { join, resolve, sep } from 'path';
 import { homedir } from 'os';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
+import { resolveDataDir } from '../lib/resolve-data-dir.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 DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
 const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
 // 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

package/scripts/pre-tool-recall.js

@@ -6,7 +6,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { basename, join } from 'path';
-import { homedir } from 'os';
+import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
 import { buildNotLowSignalSql } from '../lib/low-signal-patterns.mjs';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
 import { citeFactorClause } from '../scoring-sql.mjs';
@@ -18,7 +18,7 @@ import { presentIdents } from '../lib/lesson-idents.mjs';
 // CLAUDE_MEM_DIR matches schema.mjs / main CLI — one env var sandboxes the
 // whole system. CLAUDE_MEM_DB_PATH / CLAUDE_MEM_RUNTIME_DIR remain as
 // per-component overrides for tests that mix isolated + real paths.
-const DATA_DIR = process.env.CLAUDE_MEM_DIR || join(homedir(), '.claude-mem-lite');
+const DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
 const DB_PATH = process.env.CLAUDE_MEM_DB_PATH || join(DATA_DIR, 'claude-mem-lite.db');
 const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
 // A3 (v2.83): cross-hook dedup window — must mirror DEDUP_STALE_MS in

package/source-files.mjs

@@ -29,6 +29,12 @@ export const SOURCE_FILES = [
   'tier.mjs', 'tfidf.mjs',
   'nlp.mjs', 'synonyms.mjs', 'scoring-sql.mjs', 'stop-words.mjs', 'project-utils.mjs',
   'secret-scrub.mjs', 'format-utils.mjs', 'hash-utils.mjs', 'bash-utils.mjs',
+  // Single source of truth for the CLAUDE_MEM_DIR → data-dir resolver (rejects a
+  // stringified "undefined"/"null"/relative env instead of creating a stray dir).
+  // Statically imported by schema.mjs / cli.mjs / install.mjs / registry-recommend.mjs
+  // AND hook scripts (pre-tool-recall / post-tool-recall / pre-skill-bridge) — ship it
+  // or auto-update leaves schema + every hook with ERR_MODULE_NOT_FOUND on each fire.
+  'lib/resolve-data-dir.mjs',
   // lib/ — statically imported by hook-llm.mjs (activity) + hook-handoff.mjs (git-state, task-reader);
   // dynamically imported by hook.mjs (startup-dashboard) + mem-cli.mjs (doctor-benchmark, plan-reader).
   'lib/activity.mjs',