claude-mem-lite 3.96.0 → 3.97.0

package/claudemd.mjs

@@ -24,20 +24,34 @@ import { memdirPath, removePluginSection, removePluginDoc, isAdopted as memdirIs
 
 // ─── Path helpers ────────────────────────────────────────────────────────────
 
-function slugSnake(slug) { return String(slug).replace(/[^a-zA-Z0-9]/g, '_'); }
+function slugSnake(slug) {
+  return String(slug).replace(/[^a-zA-Z0-9]/g, '_');
+}
 
-export function claudeMdPath(cwd) { return join(cwd, 'CLAUDE.md'); }
-function dotClaudeDir(cwd) { return join(cwd, '.claude'); }
-export function detailDocPath(cwd, slug) { return join(dotClaudeDir(cwd), `plugin_${slugSnake(slug)}.md`); }
-function stateFilePath(cwd, slug) { return join(dotClaudeDir(cwd), `.plugin_${slugSnake(slug)}_state.json`); }
+export function claudeMdPath(cwd) {
+  return join(cwd, 'CLAUDE.md');
+}
+function dotClaudeDir(cwd) {
+  return join(cwd, '.claude');
+}
+export function detailDocPath(cwd, slug) {
+  return join(dotClaudeDir(cwd), `plugin_${slugSnake(slug)}.md`);
+}
+function stateFilePath(cwd, slug) {
+  return join(dotClaudeDir(cwd), `.plugin_${slugSnake(slug)}_state.json`);
+}
 
 // First line of the detail doc — an invisible (in rendered markdown) marker that
 // lets us distinguish our generated copy from a user's same-named file.
-function managedByMarker(slug) { return `<!-- managed-by: ${slug} -->`; }
+function managedByMarker(slug) {
+  return `<!-- managed-by: ${slug} -->`;
+}
 
 // ─── Sentinel rendering & parsing ────────────────────────────────────────────
 
-function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 
 // Slug-scoped so stripping our block never disturbs another plugin's block
 // (e.g. code-graph-mcp's `<!-- code-graph-mcp:begin -->`) sitting in the same
@@ -45,15 +59,23 @@ function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 // are `\r?\n` (not bare `\n`) so a CLAUDE.md re-saved with Windows CRLF endings
 // still matches — otherwise the block read as "absent" and a fresh LF copy got
 // appended every SessionStart, growing the file without bound (review C1/H2).
-function blockBody(esc) { return `<!-- ${esc}:begin (v\\d+) -->\\r?\\n([\\s\\S]*?)\\r?\\n<!-- ${esc}:end -->`; }
-function blockRegex(slug) { return new RegExp(blockBody(escapeRe(slug))); }
-function blockRegexG(slug) { return new RegExp(blockBody(escapeRe(slug)), 'g'); }
+function blockBody(esc) {
+  return `<!-- ${esc}:begin (v\\d+) -->\\r?\\n([\\s\\S]*?)\\r?\\n<!-- ${esc}:end -->`;
+}
+function blockRegex(slug) {
+  return new RegExp(blockBody(escapeRe(slug)));
+}
+function blockRegexG(slug) {
+  return new RegExp(blockBody(escapeRe(slug)), 'g');
+}
 
 function renderBlock(slug, version, body) {
   return `<!-- ${slug}:begin ${version} -->\n${body}\n<!-- ${slug}:end -->`;
 }
 
-function sha256(s) { return createHash('sha256').update(s).digest('hex'); }
+function sha256(s) {
+  return createHash('sha256').update(s).digest('hex');
+}
 
 // `atomicWriteFileSync`, not a local temp+rename (audit 2026-09-02 P0-5). The local twin
 // renamed onto the PATH; when a project's CLAUDE.md is a symlink into a dotfiles repo
@@ -71,7 +93,12 @@ function writeState(cwd, slug, state) {
 
 function clearState(cwd, slug) {
   const p = stateFilePath(cwd, slug);
-  if (existsSync(p)) try { unlinkSync(p); } catch { /* best-effort */ }
+  if (existsSync(p))
+    try {
+      unlinkSync(p);
+    } catch {
+      /* best-effort */
+    }
 }
 
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -110,9 +137,11 @@ export function isAdopted(cwd, slug) {
  * removed it. removeManaged cleans all three pieces, so sweep on any of them.
  */
 export function hasResidue(cwd, slug) {
-  return readBlock(cwd, slug).body !== null
-    || existsSync(detailDocPath(cwd, slug))
-    || existsSync(stateFilePath(cwd, slug));
+  return (
+    readBlock(cwd, slug).body !== null ||
+    existsSync(detailDocPath(cwd, slug)) ||
+    existsSync(stateFilePath(cwd, slug))
+  );
 }
 
 /**
@@ -131,7 +160,11 @@ export function needsRefresh(cwd, { slug, version, block, doc }) {
   const dp = detailDocPath(cwd, slug);
   if (!existsSync(dp)) return true;
   let cur;
-  try { cur = readFileSync(dp, 'utf8'); } catch { return true; }
+  try {
+    cur = readFileSync(dp, 'utf8');
+  } catch {
+    return true;
+  }
   return cur !== `${managedByMarker(slug)}\n${doc}`;
 }
 
@@ -227,21 +260,32 @@ export function removeManaged(cwd, slug) {
       // 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); }
+        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 */ }
+  if (existsSync(dp))
+    try {
+      unlinkSync(dp);
+    } catch {
+      /* best-effort */
+    }
   clearState(cwd, slug);
   // Drop an emptied .claude/ so unadopt leaves no trace (skips if it holds
   // anything else — e.g. settings.local.json).
   try {
     const dir = dotClaudeDir(cwd);
     if (existsSync(dir) && readdirSync(dir).length === 0) rmdirSync(dir);
-  } catch { /* best-effort */ }
+  } catch {
+    /* best-effort */
+  }
   return { action };
 }
 

package/cli/activity.mjs

@@ -16,7 +16,7 @@ import { parseIntFlag, isNumericToken } from '../lib/cli-flags.mjs';
 
 function formatActivityResults(rows) {
   if (!rows || rows.length === 0) return '(no events)';
-  return rows.map(r => `#${r.id} [${r.event_type}] ${r.title}`).join('\n');
+  return rows.map((r) => `#${r.id} [${r.event_type}] ${r.title}`).join('\n');
 }
 
 export async function cmdActivity(db, args) {
@@ -27,7 +27,8 @@ export async function cmdActivity(db, args) {
   }
 
   const { positional, flags } = parseArgs(args.slice(1));
-  const { saveEvent, searchEvents, recentEvents, getEvent, EVENT_TYPES, promoteInsightEvents } = await import('../lib/activity.mjs');
+  const { saveEvent, searchEvents, recentEvents, getEvent, EVENT_TYPES, promoteInsightEvents } =
+    await import('../lib/activity.mjs');
   const VALID_EVENT_TYPES = new Set(EVENT_TYPES);
   // `save` CREATES a row, so it keeps plain inferProject(): the DB-aware fallback is a read
   // affordance, and applying it to a write absorbs a not-yet-born subproject's first event
@@ -35,7 +36,9 @@ export async function cmdActivity(db, args) {
   // operates on rows that already exist, where falling back is what finds them.
   const project = flags.project
     ? resolveProject(db, flags.project)
-    : (sub === 'save' ? inferProject() : cliProject(db));
+    : sub === 'save'
+      ? inferProject()
+      : cliProject(db);
 
   if (sub === 'save') {
     // Reject value-less string flags before they reach saveEvent as a boolean `true`
@@ -54,16 +57,23 @@ export async function cmdActivity(db, args) {
     const body = flags.body || null;
     // Accept both --file (singular, backward compat) and --files (plural,
     // comma-split, preferred — matches cmdSave). Merge both sources.
-    const filesFromPlural = flags.files && typeof flags.files === 'string'
-      ? flags.files.split(',').map(s => s.trim()).filter(Boolean)
-      : [];
+    const filesFromPlural =
+      flags.files && typeof flags.files === 'string'
+        ? flags.files
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
     const filesFromSingular = flags.file && typeof flags.file === 'string' ? [flags.file] : [];
     const file_paths_merged = [...filesFromSingular, ...filesFromPlural];
     const file_paths = file_paths_merged.length > 0 ? file_paths_merged : null;
     const rawImp = flags.importance !== undefined ? parseInt(flags.importance, 10) : 2;
     // isNumericToken first (mirrors cmdSave): bare parseInt coerces "3xyz"→3 and would
     // persist a wrong importance that silently skews ranking. Float literals truncate (#8277).
-    if (flags.importance !== undefined && (!isNumericToken(flags.importance) || isNaN(rawImp) || rawImp < 1 || rawImp > 3)) {
+    if (
+      flags.importance !== undefined &&
+      (!isNumericToken(flags.importance) || isNaN(rawImp) || rawImp < 1 || rawImp > 3)
+    ) {
       fail(`[mem] Invalid importance "${flags.importance}". Must be 1, 2, or 3.`);
       return;
     }
@@ -101,9 +111,10 @@ export async function cmdActivity(db, args) {
     // through parseIntFlag so garbage ("2abc"), negatives (SQLite LIMIT -1 = UNLIMITED
     // full-table dump), and uncapped huge values warn + clamp to default/max, matching
     // the search/recent/browse siblings.
-    const limit = positional.length > 0
-      ? parseIntFlag(positional[0], { name: 'count', defaultValue: 20, max: 1000 })
-      : parseIntFlag(flags.limit, { name: '--limit', defaultValue: 20, max: 1000 });
+    const limit =
+      positional.length > 0
+        ? parseIntFlag(positional[0], { name: 'count', defaultValue: 20, max: 1000 })
+        : parseIntFlag(flags.limit, { name: '--limit', defaultValue: 20, max: 1000 });
     const type = flags.type || null;
     if (type !== null && !VALID_EVENT_TYPES.has(type)) {
       fail(`[mem] activity recent: invalid --type "${type}". Valid: ${[...VALID_EVENT_TYPES].join(', ')}`);
@@ -142,18 +153,21 @@ export async function cmdActivity(db, args) {
       fail('[mem] Usage: claude-mem-lite activity delete <id1,id2,...> [--confirm]');
       return;
     }
-    const ids = idStr.split(',')
-      .map(s => s.trim())
+    const ids = idStr
+      .split(',')
+      .map((s) => s.trim())
       .filter(Boolean)
-      .map(s => parseInt(s, 10))
-      .filter(n => Number.isInteger(n) && n > 0);
+      .map((s) => parseInt(s, 10))
+      .filter((n) => Number.isInteger(n) && n > 0);
     if (ids.length === 0) {
       fail('[mem] activity delete: no valid IDs provided (must be positive integers)');
       return;
     }
 
     const placeholders = ids.map(() => '?').join(',');
-    const rows = db.prepare(`SELECT id, event_type, title FROM events WHERE id IN (${placeholders})`).all(...ids);
+    const rows = db
+      .prepare(`SELECT id, event_type, title FROM events WHERE id IN (${placeholders})`)
+      .all(...ids);
     if (rows.length === 0) {
       fail(`[mem] activity delete: no events found for ID(s) ${ids.join(', ')}`);
       return;
@@ -166,7 +180,7 @@ export async function cmdActivity(db, args) {
         const titleStr = (r.title || '').slice(0, 100);
         out(`  #${r.id} [${r.event_type}] ${titleStr}`);
       }
-      const missingIds = ids.filter(i => !rows.some(r => r.id === i));
+      const missingIds = ids.filter((i) => !rows.some((r) => r.id === i));
       if (missingIds.length > 0) {
         out(`[mem] Note: ${missingIds.length} ID(s) not found and will be skipped: ${missingIds.join(', ')}`);
       }
@@ -192,11 +206,15 @@ export async function cmdActivity(db, args) {
     const execute = flags.execute === true || flags.execute === 'true';
     const r = promoteInsightEvents(db, { project: projectFilter, minImportance: minImp, execute });
     if (!execute) {
-      out(`[mem] Preview: ${r.eligible} insight-bearing event(s) (body + importance>=${minImp})${projectFilter ? ` in ${projectFilter}` : ' across all projects'} would be promoted to searchable observations.`);
+      out(
+        `[mem] Preview: ${r.eligible} insight-bearing event(s) (body + importance>=${minImp})${projectFilter ? ` in ${projectFilter}` : ' across all projects'} would be promoted to searchable observations.`,
+      );
       out('[mem] Run with --execute to apply. Source events are kept (marked promoted).');
       return;
     }
-    out(`[mem] Promoted ${r.promoted} event(s) to observations${r.deduped ? ` (${r.deduped} already had an equivalent observation)` : ''}.`);
+    out(
+      `[mem] Promoted ${r.promoted} event(s) to observations${r.deduped ? ` (${r.deduped} already had an equivalent observation)` : ''}.`,
+    );
     return;
   }
 

package/cli/common.mjs

@@ -173,7 +173,7 @@ export function rejectBareStringFlags(flags, keys) {
  * @returns {string|null} Resolved value, or null after a conflict fail().
  */
 export function resolvePositionalAlias(positionalStr, flags, aliasKeys) {
-  const given = aliasKeys.filter(k => typeof flags[k] === 'string' && flags[k].trim() !== '');
+  const given = aliasKeys.filter((k) => typeof flags[k] === 'string' && flags[k].trim() !== '');
   if (given.length > 1) {
     fail(`[mem] Both --${given[0]} and --${given[1]} provided — pass the value once.`);
     return null;
@@ -197,21 +197,99 @@ export function resolvePositionalAlias(positionalStr, flags, aliasKeys) {
  * them to a command — same maintenance contract as JSON_SUPPORTED_CMDS in mem-cli.
  */
 export const KNOWN_CLI_FLAGS = new Set([
-  'after', 'age-days', 'all', 'anchor', 'batch', 'before', 'benchmark', 'body', 'branch',
-  'capability-summary', 'category', 'closes-deferred', 'concepts', 'confirm', 'days', 'deep',
-  'detail', 'domain-tags', 'dry-run', 'enrich', 'execute', 'fields', 'file', 'files', 'floors',
-  'force', 'format', 'from', 'help', 'id', 'ids', 'content', 'importance', 'include-compressed', 'include-noise',
-  'intent-tags', 'invocation-name', 'json', 'key', 'keywords', 'lesson', 'lesson-learned', 'limit',
-  'local-path', 'margins', 'max', 'memdir', 'merge-ids', 'metrics', 'name', 'narrative', 'no-deep',
-  'offset', 'ops', 'or', 'priority', 'project', 'quality', 'query', 'reason', 'repo-url',
-  'rerank', 'resource-type', 'retain-days', 'retry', 'run', 'run-all', 'scope', 'session-audit',
-  'sidechain', 'since', 'sort', 'source', 'status', 'sweep', 'task', 'tech-stack', 'text', 'tier', 'title',
-  'to', 'trigger-patterns', 'type', 'use-cases', 'verbose',
+  'after',
+  'age-days',
+  'all',
+  'anchor',
+  'batch',
+  'before',
+  'benchmark',
+  'body',
+  'branch',
+  'capability-summary',
+  'category',
+  'closes-deferred',
+  'concepts',
+  'confirm',
+  'days',
+  'deep',
+  'detail',
+  'domain-tags',
+  'dry-run',
+  'enrich',
+  'execute',
+  'fields',
+  'file',
+  'files',
+  'floors',
+  'force',
+  'format',
+  'from',
+  'help',
+  'id',
+  'ids',
+  'content',
+  'importance',
+  'include-compressed',
+  'include-noise',
+  'intent-tags',
+  'invocation-name',
+  'json',
+  'key',
+  'keywords',
+  'lesson',
+  'lesson-learned',
+  'limit',
+  'local-path',
+  'margins',
+  'max',
+  'memdir',
+  'merge-ids',
+  'metrics',
+  'name',
+  'narrative',
+  'no-deep',
+  'offset',
+  'ops',
+  'or',
+  'priority',
+  'project',
+  'quality',
+  'query',
+  'reason',
+  'repo-url',
+  'rerank',
+  'resource-type',
+  'retain-days',
+  'retry',
+  'run',
+  'run-all',
+  'scope',
+  'session-audit',
+  'sidechain',
+  'since',
+  'sort',
+  'source',
+  'status',
+  'sweep',
+  'task',
+  'tech-stack',
+  'text',
+  'tier',
+  'title',
+  'to',
+  'trigger-patterns',
+  'type',
+  'use-cases',
+  'verbose',
   // Catalogued 2026-08-13 when suggestUnknownFlags started reporting EVERY unknown
   // flag: these are real, code-read flags that the old edit-distance gate happened to
   // stay silent about (`adopt --disable/--enable`, `activity --min-importance`,
   // `save --supersedes`). Verified by running each command and checking for a warning.
-  'disable', 'enable', 'min-importance', 'supersedes',
+  'disable',
+  'enable',
+  'min-importance',
+  'supersedes',
   // `doctor --benchmark --prompts-limit N` — read off raw argv in cli/doctor.mjs, so
   // it never appeared in a `flags.x` grep. Caught by independent review after the
   // warn-on-every-unknown-flag flip turned the omission into a false warning on a
@@ -230,7 +308,8 @@ export const KNOWN_CLI_FLAGS = new Set([
 
 /** Levenshtein distance, early-exit past `max` (cheap enough for a handful of flags). */
 function editDistance(a, b, max = 2) {
-  const m = a.length, n = b.length;
+  const m = a.length,
+    n = b.length;
   if (Math.abs(m - n) > max) return max + 1;
   let prev = Array.from({ length: n + 1 }, (_, j) => j);
   for (let i = 1; i <= m; i++) {
@@ -261,10 +340,14 @@ export function suggestUnknownFlags(flags) {
   const result = [];
   for (const key of Object.keys(flags)) {
     if (!key || KNOWN_CLI_FLAGS.has(key)) continue;
-    let best = null, bestDist = 3;
+    let best = null,
+      bestDist = 3;
     for (const known of KNOWN_CLI_FLAGS) {
       const d = editDistance(key, known);
-      if (d < bestDist) { bestDist = d; best = known; }
+      if (d < bestDist) {
+        bestDist = d;
+        best = known;
+      }
     }
     // Report EVERY unknown flag; the suggestion is a bonus when a near-miss exists.
     // Previously an unknown flag with no neighbour within distance 2 produced no
@@ -365,9 +448,9 @@ export { parseIdToken } from '../lib/id-routing.mjs';
  */
 export function formatProbeHints(probe) {
   const hints = [];
-  if (probe.obs.length > 0)     hints.push(`#${probe.obs.join(', #')} (obs)`);
+  if (probe.obs.length > 0) hints.push(`#${probe.obs.join(', #')} (obs)`);
   if (probe.session.length > 0) hints.push(`S#${probe.session.join(', S#')} (session)`);
-  if (probe.prompt.length > 0)  hints.push(`P#${probe.prompt.join(', P#')} (prompt)`);
-  if (probe.event?.length > 0)  hints.push(`E#${probe.event.join(', E#')} (event)`);
+  if (probe.prompt.length > 0) hints.push(`P#${probe.prompt.join(', P#')} (prompt)`);
+  if (probe.event?.length > 0) hints.push(`E#${probe.event.join(', E#')} (event)`);
   return hints;
 }

package/cli/doctor.mjs

@@ -25,7 +25,9 @@ export async function cmdDoctor(db, args) {
         const parsed = parseInt(args[limitIdx + 1], 10);
         if (Number.isFinite(parsed) && parsed > 0 && parsed <= 1000) limit = parsed;
       }
-      const rows = db.prepare(`
+      const rows = db
+        .prepare(
+          `
         SELECT p.prompt_text
         FROM user_prompts p
         JOIN sdk_sessions s ON p.content_session_id = s.content_session_id
@@ -34,9 +36,13 @@ export async function cmdDoctor(db, args) {
           AND length(p.prompt_text) >= 15
         ORDER BY p.created_at_epoch DESC
         LIMIT ?
-      `).all(project, limit);
-      prompts = rows.map(r => r.prompt_text).filter(Boolean);
-    } catch { /* missing/empty tables on a fresh DB → leave prompts=[] */ }
+      `,
+        )
+        .all(project, limit);
+      prompts = rows.map((r) => r.prompt_text).filter(Boolean);
+    } catch {
+      /* missing/empty tables on a fresh DB → leave prompts=[] */
+    }
     const result = runBenchmark(db, { project, prompts });
     out(JSON.stringify(result, null, 2));
     return;
@@ -79,14 +85,28 @@ export async function cmdDoctor(db, args) {
       out(`  obs_importance_null (NULL importance, P3-14):      ${audit.obs_importance_null}`);
       if (audit.id_mix_other > 0 && audit.id_mix_uuid_shape === 0) {
         out('\n  Notes:');
-        out('    • id_mix_other > 0 with uuid_shape=0 is typically benign — usually means insertSession({id:\'X\'}) test scaffold or pre-v30 data with non-UUID equal values. Does NOT drive failure.');
+        out(
+          "    • id_mix_other > 0 with uuid_shape=0 is typically benign — usually means insertSession({id:'X'}) test scaffold or pre-v30 data with non-UUID equal values. Does NOT drive failure.",
+        );
       }
       if (!audit.healthy) {
         out('\n  Notes:');
-        if (audit.id_mix_uuid_shape > 0) out('    • id_mix_uuid_shape > 0 — production v2.33.1 bug-pattern rows present. Investigate via SQL: SELECT * FROM sdk_sessions WHERE memory_session_id = content_session_id AND length(memory_session_id) = 36;');
-        if (audit.missing_mem_id > 0) out('    • missing_mem_id rows are sessions whose mem-internal ID was never populated — likely SessionStart write that didn\'t reach Stop');
-        if (audit.orphan_obs > 0) out('    • orphan_obs are observations referencing a sdk_sessions row that was deleted (FK CASCADE failed historically before v28)');
-        if (audit.obs_importance_null > 0) out('    • obs_importance_null rows read as importance 1 by the CLI/hook maintenance pass (COALESCE) and as "skip" by the MCP idle pass (bare `importance <= 1`), so they decay on one face and not the other. New rows cannot reach this state (lib/observation-write.mjs coerces nullish to 1); these predate that or were written around it. Fix: UPDATE observations SET importance = 1 WHERE importance IS NULL;');
+        if (audit.id_mix_uuid_shape > 0)
+          out(
+            '    • id_mix_uuid_shape > 0 — production v2.33.1 bug-pattern rows present. Investigate via SQL: SELECT * FROM sdk_sessions WHERE memory_session_id = content_session_id AND length(memory_session_id) = 36;',
+          );
+        if (audit.missing_mem_id > 0)
+          out(
+            "    • missing_mem_id rows are sessions whose mem-internal ID was never populated — likely SessionStart write that didn't reach Stop",
+          );
+        if (audit.orphan_obs > 0)
+          out(
+            '    • orphan_obs are observations referencing a sdk_sessions row that was deleted (FK CASCADE failed historically before v28)',
+          );
+        if (audit.obs_importance_null > 0)
+          out(
+            '    • obs_importance_null rows read as importance 1 by the CLI/hook maintenance pass (COALESCE) and as "skip" by the MCP idle pass (bare `importance <= 1`), so they decay on one face and not the other. New rows cannot reach this state (lib/observation-write.mjs coerces nullish to 1); these predate that or were written around it. Fix: UPDATE observations SET importance = 1 WHERE importance IS NULL;',
+          );
       }
     }
     if (!audit.healthy) process.exitCode = 1;

package/cli.mjs

@@ -1,6 +1,46 @@
 #!/usr/bin/env node
-const CLI_COMMANDS = new Set(['search', 'recent', 'recall', 'get', 'timeline', 'save', 'stats', 'context', 'browse', 'citation-stats', 'delete', 'update', 'export', 'restore', 'compress', 'maintain', 'optimize', 'fts-check', 'registry', 'import', 'import-jsonl', 'enrich', 'activity', 'adopt', 'unadopt', 'memdir-audit', 'defer', 'help']);
-const INSTALL_COMMANDS = new Set(['install', 'uninstall', 'status', 'doctor', 'cleanup', 'cleanup-hooks', 'self-update', 'repair', 'rebuild-binding', 'release']);
+const CLI_COMMANDS = new Set([
+  'search',
+  'recent',
+  'recall',
+  'get',
+  'timeline',
+  'save',
+  'stats',
+  'context',
+  'browse',
+  'citation-stats',
+  'delete',
+  'update',
+  'export',
+  'restore',
+  'compress',
+  'maintain',
+  'optimize',
+  'fts-check',
+  'registry',
+  'import',
+  'import-jsonl',
+  'enrich',
+  'activity',
+  'adopt',
+  'unadopt',
+  'memdir-audit',
+  'defer',
+  'help',
+]);
+const INSTALL_COMMANDS = new Set([
+  'install',
+  'uninstall',
+  'status',
+  'doctor',
+  'cleanup',
+  'cleanup-hooks',
+  'self-update',
+  'repair',
+  'rebuild-binding',
+  'release',
+]);
 
 const cmd = process.argv[2];
 
@@ -17,7 +57,10 @@ if (cmd === '--version' || cmd === '-v' || cmd === '-V' || cmd === 'version') {
 } else if (cmd === '--help' || cmd === '-h') {
   const { run } = await import('./mem-cli.mjs');
   await run(['help']);
-} else if (cmd === 'doctor' && process.argv.slice(3).some(a => a === '--benchmark' || a === '--metrics' || a === '--session-audit')) {
+} else if (
+  cmd === 'doctor' &&
+  process.argv.slice(3).some((a) => a === '--benchmark' || a === '--metrics' || a === '--session-audit')
+) {
   // Per #8217: the DB-layer doctor modes (--benchmark / --metrics / --session-audit,
   // each implemented in cli/doctor.mjs) route to mem-cli. Everything else — plain
   // `doctor`, `doctor --` (POSIX end-of-options), and `doctor --json` — stays with
@@ -56,19 +99,35 @@ if (cmd === '--version' || cmd === '-v' || cmd === '-V' || cmd === 'version') {
   process.stderr.write(`[mem] Unknown command: "${cmd}"\n`);
   // Suggest closest command by edit distance
   const allCmds = [...CLI_COMMANDS, ...INSTALL_COMMANDS];
-  let best = null, bestDist = Infinity;
+  let best = null,
+    bestDist = Infinity;
   for (const c of allCmds) {
-    const a = cmd.toLowerCase(), b = c;
-    const m = a.length, n = b.length;
+    const a = cmd.toLowerCase(),
+      b = c;
+    const m = a.length,
+      n = b.length;
     if (Math.abs(m - n) > 2) continue;
-    const d = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
-    for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) d[i][j] = Math.min(d[i-1][j] + 1, d[i][j-1] + 1, d[i-1][j-1] + (a[i-1] !== b[j-1] ? 1 : 0));
-    if (d[m][n] < bestDist) { bestDist = d[m][n]; best = c; }
+    const d = Array.from({ length: m + 1 }, (_, i) =>
+      Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
+    );
+    for (let i = 1; i <= m; i++)
+      for (let j = 1; j <= n; j++)
+        d[i][j] = Math.min(
+          d[i - 1][j] + 1,
+          d[i][j - 1] + 1,
+          d[i - 1][j - 1] + (a[i - 1] !== b[j - 1] ? 1 : 0),
+        );
+    if (d[m][n] < bestDist) {
+      bestDist = d[m][n];
+      best = c;
+    }
   }
   if (best && bestDist <= 2) {
     process.stderr.write(`[mem] Did you mean: ${best}?\n`);
   } else {
-    process.stderr.write('[mem] Run "claude-mem-lite help" for CLI commands or "claude-mem-lite install" for setup\n');
+    process.stderr.write(
+      '[mem] Run "claude-mem-lite help" for CLI commands or "claude-mem-lite install" for setup\n',
+    );
   }
   process.exitCode = 1;
 }