claude-mem-lite 2.95.1 → 2.97.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.95.1",
+      "version": "2.97.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.95.1",
+  "version": "2.97.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/common.mjs

@@ -98,6 +98,24 @@ export function fmtDateShort(iso) {
   return iso.slice(0, 10);
 }
 
+// Integer epoch-ms time fields on the observations table that `get`/`mem_get`
+// render. Shared by the CLI (mem-cli.mjs) and the MCP server (server.mjs) so the
+// two `get` paths can't drift — pre-2.97 the MCP path printed bare ms
+// (`last_accessed_at: 1781024049720`) while the CLI showed `<ms> (<relative>)`,
+// because the formatter lived only in mem-cli.mjs.
+export const OBS_TIME_FIELDS = ['superseded_at', 'last_accessed_at'];
+
+// Pure formatter — null/undefined/non-time pass through; integer time fields
+// render as `<raw> (<relative>)` so callers get both an audit value and a
+// human/LLM-scannable hint, mirroring `recent`/`timeline`/`recall`.
+export function formatObsFieldValue(field, val) {
+  if (val === null || val === undefined) return val;
+  if (OBS_TIME_FIELDS.includes(field) && typeof val === 'number') {
+    return `${val} (${relativeTime(val)})`;
+  }
+  return val;
+}
+
 // ─── ID Token Parsing ────────────────────────────────────────────────────────
 // Re-exported from lib/id-routing.mjs so CLI and MCP (server.mjs) share a single
 // parser — parity per #8050. Keep this re-export for back-compat with the

package/hook-llm.mjs

@@ -601,7 +601,12 @@ export async function handleLLMEpisode() {
     await sleep(delayMs);
   }
 
-  const fileList = episode.files.map(f => basename(f)).join(', ') || '(multiple)';
+  // `episode.files` is normally a [] from createEpisode, but a malformed or
+  // older-format tmp file can omit it — `.map()` on undefined would throw here,
+  // before any cleanup, leaking the tmp file (which is then retried and crashes
+  // forever). Guard defensively, mirroring buildImmediateObservation's `|| []`.
+  const episodeFiles = Array.isArray(episode.files) ? episode.files : [];
+  const fileList = episodeFiles.map(f => basename(f)).join(', ') || '(multiple)';
 
   // Defense-in-depth (cso F#4): split static instructions (system) from
   // per-call data (user). Episode descriptions and file paths come from tool
@@ -622,7 +627,7 @@ search_aliases: 2-6 alternative search terms someone might use to find this memo
 JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"concise ≤80 char description","narrative":"what changed, why, and outcome (2-3 sentences)","concepts":["kw1","kw2"],"facts":["fact1","fact2"],"importance":1,"lesson_learned":"non-obvious insight a future session needs, or null","search_aliases":["alt query 1","alt query 2"]}
 ${SHARED_OBS_SCHEMA_TAIL}`;
     const user = `Tool: ${e.tool}
-File: ${episode.files.join(', ') || 'unknown'}
+File: ${episodeFiles.join(', ') || 'unknown'}
 Action: ${e.desc}
 Error: ${e.isError ? 'yes' : 'no'}`;
     prompt = { system, user };
@@ -743,7 +748,7 @@ ${actionList}`;
         narrative: truncate(parsed.narrative || '', 500),
         concepts: Array.isArray(parsed.concepts) ? parsed.concepts.slice(0, 10) : [],
         facts: Array.isArray(parsed.facts) ? parsed.facts.slice(0, 10) : [],
-        files: episode.files,
+        files: episodeFiles,
         filesRead: episode.filesRead || [],
         // v2.33.1: when lesson is low-signal, don't trust Haiku's importance
         // inflation. v2.54.0: extended from {change, discovery} to all types
@@ -752,7 +757,12 @@ ${actionList}`;
         // imp=2-3 even when lesson is null after retry. Keep `decision` exempt:
         // it's rare (39 obs / 94.9% hit-rate) and the retry path already gave
         // it a second chance; a no-lesson decision is still a worthwhile signal.
-        importance: isLessonLowSignal && parsed.type !== 'decision'
+        // `!retryRecovered`: when the P3 retry recovered a substantive lesson,
+        // the obs is no longer low-signal — capping it to 1 would negate the
+        // retry's entire purpose (a recovered bugfix lesson would silently drop
+        // out of --importance 2 searches and the working tier). Gate the cap on
+        // the *effective* low-signal state, not the pre-retry flag.
+        importance: isLessonLowSignal && !retryRecovered && parsed.type !== 'decision'
           ? Math.min(ruleImportance, 1)
           : Math.max(ruleImportance, clampImportance(parsed.importance)),
         lessonLearned,

package/hook-update.mjs

@@ -155,8 +155,22 @@ function isPluginMode() {
 // ── Dev Mode Detection ─────────────────────────────────────
 function isDevMode() {
   try {
-    const serverPath = join(INSTALL_DIR, 'server.mjs');
-    return existsSync(serverPath) && lstatSync(serverPath).isSymbolicLink();
+    // A dev checkout always carries a .git dir. This catches a whole-directory
+    // symlink (~/.claude-mem-lite -> /repo): lstat on server.mjs there follows the
+    // intermediate symlink and sees a regular file, so the per-file probe below
+    // would return false and auto-update would clobber the working tree.
+    if (existsSync(join(INSTALL_DIR, '.git'))) return true;
+    // Standard `install --dev` symlinks individual source files; checking several
+    // core files (not just server.mjs) survives the drift case where one file was
+    // replaced by a plain copy while the install is still symlink-provisioned —
+    // mirrors lib/doctor-drift.mjs's "any symlink ⇒ dev" detection. A copy-based
+    // real install (install.mjs non-dev) has no symlinks and no .git, so this
+    // cannot false-positive into never auto-updating.
+    for (const f of ['server.mjs', 'hook.mjs', 'cli.mjs', 'mem-cli.mjs']) {
+      const p = join(INSTALL_DIR, f);
+      if (existsSync(p) && lstatSync(p).isSymbolicLink()) return true;
+    }
+    return false;
   } catch { return false; }
 }
 

package/install.mjs

@@ -302,6 +302,43 @@ function isDevInstall() {
   }
 }
 
+// Decide what to check out of a registry repo. We only ever copy the manifest's
+// `entry.path` subdirs into managed/skills|agents, so the working tree never
+// needs the rest of the repo — a partial+sparse clone fetches just those subtrees
+// (e.g. davila7/claude-code-templates: 197MB whole repo → a few MB of 3 paths).
+// Returns { full, paths }: `full` forces a normal checkout when any entry maps to
+// the repo root ('.') — sparse buys nothing there. Unsafe paths ('..'/absolute)
+// are dropped here exactly as the copy loop drops them, so they never reach
+// `sparse-checkout set`. Pure + exported for unit testing.
+export function planRepoSparsePaths(entries) {
+  let needsFull = false;
+  const paths = [];
+  for (const e of entries || []) {
+    const p = e && e.path;
+    if (!p || p === '.' || p === './') { needsFull = true; continue; }
+    if (isAbsolute(p) || String(p).includes('..')) continue; // unsafe — skipped at copy too
+    const norm = String(p).replace(/^\.\//, '').replace(/\/+$/, '');
+    if (norm && !paths.includes(norm)) paths.push(norm);
+  }
+  // No usable sparse paths (all root or all unsafe) → a full checkout is the only
+  // thing that can produce content; sparse would be an empty, pointless tree.
+  return { full: needsFull || paths.length === 0, paths };
+}
+
+// True only for a clone this code produced (partial-clone promisor + sparse-checkout
+// both on). A legacy full clone returns false → caller re-clones it slim. Detection
+// erring false only costs a one-time re-clone (the dir is a rebuildable cache), so
+// over-eager migration is safe; under-eager just keeps a fat clone one more cycle.
+function isPartialSparseClone(clonePath) {
+  const cfg = (key) => {
+    try {
+      return execFileSync('git', ['-C', clonePath, 'config', '--get', key],
+        { encoding: 'utf8', stdio: 'pipe' }).trim();
+    } catch { return ''; } // missing key → git exits non-zero → treat as unset
+  };
+  return cfg('remote.origin.promisor') === 'true' && cfg('core.sparseCheckout') === 'true';
+}
+
 // ─── Install ────────────────────────────────────────────────────────────────
 
 async function install() {
@@ -748,11 +785,39 @@ async function install() {
           const clonePath = join(managedDir, 'repos', repoName);
           let repoReady = false;
 
+          const plan = planRepoSparsePaths(entries);
+          const cloneUrl = `${repoUrl.replace(/\.git$/, '')}.git`;
+          // Clone only what we extract: a partial (blob:none) + sparse clone fetches
+          // just the manifest subpaths' subtrees instead of the whole repo. Falls
+          // back to a plain shallow clone if partial-clone/sparse-checkout is
+          // unsupported (old git/server) — identical to the prior behavior.
+          const cloneSlim = () => {
+            if (plan.full) {
+              execFileSync('git', ['clone', '--depth', '1', cloneUrl, clonePath], { stdio: 'pipe', timeout: 30000 });
+              return;
+            }
+            try {
+              execFileSync('git', ['clone', '--depth', '1', '--filter=blob:none', '--no-checkout', cloneUrl, clonePath], { stdio: 'pipe', timeout: 30000 });
+              execFileSync('git', ['-C', clonePath, 'sparse-checkout', 'set', '--no-cone', ...plan.paths], { stdio: 'pipe', timeout: 30000 });
+              execFileSync('git', ['-C', clonePath, 'checkout'], { stdio: 'pipe', timeout: 30000 });
+            } catch {
+              try { rmSync(clonePath, { recursive: true, force: true }); } catch {}
+              execFileSync('git', ['clone', '--depth', '1', cloneUrl, clonePath], { stdio: 'pipe', timeout: 30000 });
+            }
+          };
+
+          // Migrate a legacy full clone: drop it so the fresh-clone path below
+          // rebuilds it slim. managed/repos is a rebuildable cache, so this loses
+          // nothing and reclaims the bulk of its footprint on the next install run.
+          if (!plan.full && existsSync(clonePath) && !isPartialSparseClone(clonePath)) {
+            try { rmSync(clonePath, { recursive: true, force: true }); } catch {}
+          }
+
           if (!existsSync(clonePath)) {
-            // Fresh clone
+            // Fresh clone (also the rebuild path for a just-migrated legacy clone)
             try {
               mkdirSync(join(managedDir, 'repos'), { recursive: true });
-              execFileSync('git', ['clone', '--depth', '1', `${repoUrl.replace(/\.git$/, '')}.git`, clonePath], { stdio: 'pipe', timeout: 30000 });
+              cloneSlim();
               cloned++;
               repoReady = true;
             } catch (err) {
@@ -767,6 +832,11 @@ async function install() {
           } else {
             // Update existing: fetch latest and fast-forward
             try {
+              // Re-assert the sparse set so a newer manifest that adds a subpath to
+              // an already-slim clone checks it out (idempotent; no-op for full clones).
+              if (!plan.full && isPartialSparseClone(clonePath)) {
+                try { execFileSync('git', ['-C', clonePath, 'sparse-checkout', 'set', '--no-cone', ...plan.paths], { stdio: 'pipe', timeout: 30000 }); } catch {}
+              }
               const localHash = execFileSync('git', ['-C', clonePath, 'rev-parse', 'HEAD'], { encoding: 'utf8', stdio: 'pipe' }).trim();
               execFileSync('git', ['-C', clonePath, 'fetch', '--depth', '1', 'origin'], { stdio: 'pipe', timeout: 30000 });
               const remoteHash = execFileSync('git', ['-C', clonePath, 'rev-parse', 'FETCH_HEAD'], { encoding: 'utf8', stdio: 'pipe' }).trim();

package/mem-cli.mjs

@@ -33,7 +33,7 @@ import { readFileSync, existsSync, readdirSync } from 'fs';
 // v2.41: shared CLI helpers extracted to cli/common.mjs. Keep this file as the
 // router + remaining-command bodies during the incremental split. Future work:
 // move each cmdXxx into its own cli/<cmd>.mjs; mem-cli.mjs becomes pure dispatch.
-import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags } from './cli/common.mjs';
+import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, OBS_TIME_FIELDS, formatObsFieldValue } from './cli/common.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
 import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { countRecentHookErrors } from './lib/hook-telemetry.mjs';
@@ -559,24 +559,12 @@ function cmdRecall(db, args) {
 
 const OBS_FIELDS = ['id', 'type', 'title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned', 'search_aliases', 'files_read', 'files_modified', 'project', 'created_at', 'memory_session_id', 'prompt_number', 'importance', 'related_ids', 'access_count', 'branch', 'superseded_at', 'superseded_by', 'last_accessed_at'];
 
-// Integer-typed time-epoch fields on the observations table that the `get`
-// command renders. Callers expect raw ms (audit) AND a relative-time hint
-// (human-scan), so formatObsFieldValue emits both. Other epoch fields like
-// `created_at_epoch` / `optimized_at` / `last_injected_at` aren't in
-// OBS_FIELDS so they don't surface via `get`.
-export const OBS_TIME_FIELDS = ['superseded_at', 'last_accessed_at'];
-
-// Pure formatter — null/undefined/non-time pass through; time fields on
-// integer values render as `<raw> (<relative>)` mirroring the convention
-// already used by `recent` / `timeline` / `recall`. Pre-2.63.0 the get
-// path printed bare ms (e.g. `last_accessed_at: 1778357330957`).
-export function formatObsFieldValue(field, val) {
-  if (val === null || val === undefined) return val;
-  if (OBS_TIME_FIELDS.includes(field) && typeof val === 'number') {
-    return `${val} (${relativeTime(val)})`;
-  }
-  return val;
-}
+// Time-field formatting moved to cli/common.mjs so the CLI `get` and the MCP
+// `mem_get` (server.mjs) share one source and can't drift (the drift bug:
+// MCP printed bare ms while CLI showed `<ms> (<relative>)`). Imported at the
+// top; re-exported here for back-compat with existing importers
+// (tests/get-time-format.test.mjs).
+export { OBS_TIME_FIELDS, formatObsFieldValue };
 
 function renderObsRows(db, ids, requestedFields) {
   const placeholders = ids.map(() => '?').join(',');
@@ -1797,12 +1785,15 @@ function cmdExport(db, args) {
 
   // Full round-trippable column set so `restore` rebuilds observations faithfully —
   // content + value-signals (access/cited/uncited/injection/decay) + branch + timing.
-  // Additive vs the pre-v2.90 13-col shape; existing `export | jq '.[].title'` consumers
-  // are unaffected. id + memory_session_id are informational (restore remaps id and
-  // buckets under a restore session).
+  // `search_aliases` is an FTS5-indexed column (BM25 weight 5) — dropping it on
+  // export silently lost the LLM-generated alternate query terms on restore, so a
+  // restored memory became unfindable by its aliases. Additive vs the pre-v2.90
+  // 13-col shape; existing `export | jq '.[].title'` consumers are unaffected.
+  // id + memory_session_id are informational (restore remaps id and buckets under
+  // a restore session).
   const rows = db.prepare(`
     SELECT id, memory_session_id, project, type, title, subtitle, narrative, concepts, facts,
-           files_read, files_modified, lesson_learned, importance, branch,
+           files_read, files_modified, lesson_learned, search_aliases, importance, branch,
            access_count, cited_count, uncited_streak, injection_count, decay_seen_count,
            last_accessed_at, created_at, created_at_epoch
     FROM observations WHERE ${wheres.join(' AND ')}
@@ -1863,7 +1854,7 @@ function cmdRestore(db, argv) {
 
   const dupCheck = db.prepare('SELECT id FROM observations WHERE project = ? AND title = ? AND created_at_epoch = ? LIMIT 1');
   const signalUpdate = db.prepare(`UPDATE observations SET
-      subtitle = ?, concepts = ?, facts = ?, files_read = ?, branch = COALESCE(?, branch),
+      subtitle = ?, concepts = ?, facts = ?, search_aliases = ?, files_read = ?, branch = COALESCE(?, branch),
       access_count = ?, cited_count = ?, uncited_streak = ?, injection_count = ?,
       decay_seen_count = ?, last_accessed_at = ?
     WHERE id = ?`);
@@ -1893,8 +1884,10 @@ function cmdRestore(db, argv) {
       });
       if (res.kind !== 'saved') { skipped++; continue; } // saveObservation Jaccard dedup
       // Re-apply the fields saveObservation zeros/derives so the backup is faithful.
+      // search_aliases is its own FTS5 column, so this UPDATE re-syncs the index
+      // (via the observations FTS triggers) and restored aliases stay searchable.
       signalUpdate.run(
-        r.subtitle || '', r.concepts || '', r.facts || '', r.files_read || '[]', r.branch ?? null,
+        r.subtitle || '', r.concepts || '', r.facts || '', r.search_aliases ?? null, r.files_read || '[]', r.branch ?? null,
         num(r.access_count), num(r.cited_count), num(r.uncited_streak), num(r.injection_count),
         num(r.decay_seen_count), r.last_accessed_at ?? null,
         res.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.95.1",
+  "version": "2.97.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/server.mjs

@@ -20,6 +20,7 @@ import {
 } from './lib/maintain-core.mjs';
 import { effectiveQuiet, RUNTIME_DIR } from './hook-shared.mjs';
 import { computeTier, TIER_CASE_SQL, tierSqlParams } from './tier.mjs';
+import { formatObsFieldValue } from './cli/common.mjs';
 import { memSearchSchema, memRecentSchema, memTimelineSchema, memGetSchema, memDeleteSchema, memSaveSchema, memStatsSchema, memCompressSchema, memMaintainSchema, memOptimizeSchema, memUpdateSchema, memExportSchema, memRecallSchema, memFtsCheckSchema, memRegistrySchema, memBrowseSchema, memUseSchema, memDeferSchema, memDeferListSchema, memDeferDropSchema, tools as TOOL_DEFS } from './tool-schemas.mjs';
 
 // Lookup helper: all user-facing tool descriptions live in tool-schemas.mjs
@@ -801,8 +802,12 @@ server.registerTool(
           const val = row[f];
           if (val === null || val === undefined || val === '') continue;
           if (f === 'text' && row.narrative && typeof val === 'string' && val.startsWith(row.narrative)) continue;
+          // Shared formatter (cli/common.mjs) renders epoch-ms time fields as
+          // `<ms> (<relative>)` — parity with the CLI `get` path so an LLM reader
+          // gets a scannable hint instead of a bare millisecond integer.
+          const display = formatObsFieldValue(f, val);
           const maxLen = f === 'narrative' ? 1000 : f === 'lesson_learned' ? 500 : f === 'text' ? 500 : 200;
-          lines.push(`${f}: ${typeof val === 'string' && val.length > maxLen ? val.slice(0, maxLen) + '…' : val}`);
+          lines.push(`${f}: ${typeof display === 'string' && display.length > maxLen ? display.slice(0, maxLen) + '…' : display}`);
         }
         sections.push(lines.join('\n'));
       }