claude-mem-lite 3.39.2 → 3.41.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.39.2",
+      "version": "3.41.0",
       "source": "./",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."
     }

package/.claude-plugin/plugin.json

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

@@ -143,7 +143,10 @@ export function writeManaged(cwd, { slug, version, block, doc }) {
     else next = raw + '\n\n' + section + '\n';
     action = 'created';
   } else {
-    next = raw.replace(m[0], section);
+    // Function replacer (not a string): a `$`-sequence in `section` (a future template with
+    // a shell example / regex / `$1`) would otherwise be interpreted as a replacement
+    // back-reference and corrupt the block on every SessionStart refresh. Matches line 153.
+    next = raw.replace(m[0], () => section);
     action = next !== raw ? 'updated' : 'unchanged';
   }
   // H2: collapse any DUPLICATE same-slug blocks (keep the first, drop the rest).

package/hook-context.mjs

@@ -305,6 +305,7 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
       FROM observations
       WHERE COALESCE(compressed_into, 0) = 0
         AND superseded_at IS NULL
+        AND ${notLowSignalTitleClause('')}
         AND (
           (created_at_epoch > ? AND importance >= 1)
           OR (created_at_epoch > ? AND importance >= 2)

package/hook-handoff.mjs

@@ -271,13 +271,28 @@ export function detectContinuationIntent(db, promptText, project, currentCcSessi
   try {
     const currentSha = gitStateModule.readGitState({ cwd: process.cwd() }).headSha;
     if (currentSha) {
-      const anchor = db.prepare(`
-        SELECT created_at_epoch FROM session_handoffs
-        WHERE project = ? AND git_sha_at_handoff = ?
-        ORDER BY created_at_epoch DESC LIMIT 1
-      `).get(project, currentSha);
+      // Scope like Stage 2: an 'exit' anchor is cross-session (resume after /exit), but a 'clear'
+      // anchor is same-session only — else a parallel same-project session at the same commit
+      // would hijack (and then delete) another session's clear handoff.
+      const anchor = currentCcSessionId
+        ? db.prepare(`
+            SELECT created_at_epoch, match_keywords FROM session_handoffs
+            WHERE project = ? AND git_sha_at_handoff = ? AND (type = 'exit' OR session_id = ?)
+            ORDER BY created_at_epoch DESC LIMIT 1
+          `).get(project, currentSha, currentCcSessionId)
+        : db.prepare(`
+            SELECT created_at_epoch, match_keywords FROM session_handoffs
+            WHERE project = ? AND git_sha_at_handoff = ?
+            ORDER BY created_at_epoch DESC LIMIT 1
+          `).get(project, currentSha);
       if (anchor && (Date.now() - anchor.created_at_epoch <= HANDOFF_ANCHOR_MAX_AGE)) {
-        return true;
+        // Unmoved HEAD is a strong resume signal, but must not hijack a NEW task typed at the
+        // same commit: gate long prompts on keyword overlap (mirror Stage 0). Short prompts
+        // (resume nudges) auto-continue.
+        if (promptText.length < 40) return true;
+        const hTokens = anchor.match_keywords ? new Set(tokenizeHandoff(anchor.match_keywords)) : null;
+        if (!hTokens || tokenizeHandoff(promptText).some(t => hTokens.has(t))) return true;
+        // long prompt with zero keyword overlap → fall through to Stage 0/1/2
       }
     }
   } catch { /* git/DB failure must not break the rest of the pipeline */ }

package/hook-llm.mjs

@@ -11,7 +11,7 @@ import {
 } from './utils.mjs';
 import { acquireLLMSlot, releaseLLMSlot } from './hook-semaphore.mjs';
 import { scrubRecord } from './lib/scrub-record.mjs';
-import { getVocabulary, computeVector } from './tfidf.mjs';
+import { getVocabulary, computeVector, vecTextForRow } from './tfidf.mjs';
 import { insertObservationRow, insertObservationFiles, insertObservationVector } from './lib/observation-write.mjs';
 import { DEDUP_JACCARD_THRESHOLD, AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import {
@@ -124,10 +124,12 @@ function buildFtsTextField(obs) {
 // weight) and search_aliases (finding #8: previously omitted, so even with vectors
 // enabled the paraphrase-bridge alias terms were invisible to cosine similarity).
 export function buildVecText(obs) {
-  const conceptsText = Array.isArray(obs.concepts) ? obs.concepts.join(' ') : (obs.concepts || '');
-  const aliasesText = obs.searchAliases || '';
-  return [obs.title || '', obs.narrative || '', conceptsText, obs.lessonLearned || '', aliasesText]
-    .filter(Boolean).join(' ');
+  // Single source (V-F1): map the camelCase obs onto vecTextForRow's row shape so save and
+  // every rebuild path encode the identical field set (title/narrative/concepts/lesson/aliases).
+  return vecTextForRow({
+    title: obs.title, narrative: obs.narrative, concepts: obs.concepts,
+    lesson_learned: obs.lessonLearned, search_aliases: obs.searchAliases,
+  });
 }
 
 /**
@@ -996,7 +998,8 @@ ${actionList}`;
           search_aliases: obs.searchAliases || null,
         });
         db.prepare(`
-          UPDATE observations SET type=?, title=?, subtitle=?, narrative=?, concepts=?, facts=?,
+          UPDATE observations SET type=?, title=?, subtitle=?,
+            narrative=COALESCE(NULLIF(?, ''), narrative), concepts=?, facts=?,
             text=?, importance=?, files_read=?, minhash_sig=?, lesson_learned=?, search_aliases=?
           WHERE id = ?
         `).run(
@@ -1018,7 +1021,7 @@ ${actionList}`;
         try {
           const vocab = getVocabulary(db);
           if (vocab) {
-            const vecText = [obs.title || '', obs.narrative || '', conceptsText].filter(Boolean).join(' ');
+            const vecText = vecTextForRow({ title: obs.title, narrative: obs.narrative, concepts: conceptsText, lesson_learned: safe.lesson_learned, search_aliases: safe.search_aliases });
             const vec = computeVector(vecText, vocab);
             if (vec) {
               db.prepare('INSERT OR REPLACE INTO observation_vectors (observation_id, vector, vocab_version, created_at_epoch) VALUES (?, ?, ?, ?)')

package/hook-memory.mjs

@@ -255,6 +255,7 @@ export function searchRelevantMemories(db, userPrompt, project, excludeIds = [])
     try {
       const crossStmt = db.prepare(`
         SELECT o.id, o.type, o.title, o.subtitle, o.narrative, o.importance, o.lesson_learned, o.project,
+               o.created_at_epoch, o.files_modified,
                o.cited_count, o.uncited_streak,
                ${OBS_BM25} as relevance,
                ${noisePenaltyClause('o')} as noise_penalty

package/hook-optimize.mjs

@@ -12,7 +12,7 @@ import {
 import { callModelJSON } from './haiku-client.mjs';
 import { acquireLLMSlot, releaseLLMSlot } from './hook-semaphore.mjs';
 import { scrubRecord } from './lib/scrub-record.mjs';
-import { getVocabulary, computeVector, cosineSimilarity } from './tfidf.mjs';
+import { getVocabulary, computeVector, cosineSimilarity, vecTextForRow } from './tfidf.mjs';
 import { MERGE_JACCARD_LOW, AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { DB_DIR } from './schema.mjs';
 
@@ -25,9 +25,14 @@ export function distributeBudget(total = 15) {
   const reenrich = Math.max(1, Math.floor(total * 0.4));
   const clusterMerge = Math.max(1, Math.floor(total * 0.3));
   const smartCompress = Math.max(1, total - reenrich - normalize - clusterMerge);
-  // Clamp: if total is too small for 4 tasks, cap each so sum ≤ total
+  // Clamp: if total is too small for all 4 tasks, allocate 1 each by priority until `total`
+  // is exhausted so the returned sum is ≤ total (the old fallback returned {1,1,1,1}=4 for
+  // total≤3, over-running `optimize --max N`).
   if (reenrich + normalize + clusterMerge + smartCompress > total) {
-    return { reenrich: Math.max(1, total - 3), normalize: 1, clusterMerge: 1, smartCompress: 1 };
+    const alloc = { reenrich: 0, clusterMerge: 0, smartCompress: 0, normalize: 0 };
+    const order = ['reenrich', 'clusterMerge', 'smartCompress', 'normalize'];
+    for (let i = 0; i < total && i < order.length; i++) alloc[order[i]] = 1;
+    return alloc;
   }
   return { reenrich, normalize, clusterMerge, smartCompress };
 }
@@ -39,11 +44,16 @@ export function distributeBudget(total = 15) {
  * Exported for testing; also kept as the single source of vector-rebuild logic
  * for the optimize / re-enrich path to avoid drift with the hook-llm write path.
  */
-export function rebuildVector(db, obsId, textParts) {
+export function rebuildVector(db, obsId, textPartsOrRow) {
   try {
     const vocab = getVocabulary(db);
     if (!vocab) return;
-    const vec = computeVector(textParts.filter(Boolean).join(' '), vocab);
+    // Accept a legacy [parts] array OR an observation row (preferred — single-source field set
+    // incl. lesson_learned/search_aliases via vecTextForRow, so rebuilds match the save path).
+    const text = Array.isArray(textPartsOrRow)
+      ? textPartsOrRow.filter(Boolean).join(' ')
+      : vecTextForRow(textPartsOrRow);
+    const vec = computeVector(text, vocab);
     if (vec) {
       // Bug #1 fix: column is `created_at_epoch`, not `computed_at`. Every other
       // INSERT callsite (server.mjs, hook-llm.mjs, mem-cli.mjs) uses the correct
@@ -87,7 +97,7 @@ export function findReenrichCandidates(db, limit = 10, { scope = 'narrow', proje
     // deliberately NOT gated on optimized_at, so a lesson-less row can still be
     // picked up by wide scope for lesson enrichment afterward.
     const stmt = db.prepare(`
-      SELECT id, title, narrative, type, subtitle, concepts, facts, text, search_aliases, project
+      SELECT id, title, narrative, type, subtitle, concepts, facts, text, search_aliases, importance, project
       FROM observations
       WHERE COALESCE(compressed_into, 0) = 0
         AND superseded_at IS NULL
@@ -102,7 +112,7 @@ export function findReenrichCandidates(db, limit = 10, { scope = 'narrow', proje
   }
   if (scope === 'wide') {
     const stmt = db.prepare(`
-      SELECT id, title, narrative, type, subtitle, concepts, facts, search_aliases, project
+      SELECT id, title, narrative, type, subtitle, concepts, facts, search_aliases, importance, project
       FROM observations
       WHERE COALESCE(compressed_into, 0) = 0
         AND superseded_at IS NULL
@@ -120,7 +130,7 @@ export function findReenrichCandidates(db, limit = 10, { scope = 'narrow', proje
     return project ? stmt.all(project, limit) : stmt.all(limit);
   }
   const stmt = db.prepare(`
-    SELECT id, title, narrative, type, subtitle, project
+    SELECT id, title, narrative, type, subtitle, importance, project
     FROM observations
     WHERE COALESCE(compressed_into, 0) = 0
       AND (concepts IS NULL OR concepts = '')
@@ -205,7 +215,10 @@ search_aliases: 2-6 alternative search terms (include CJK if applicable).`;
         continue;
       }
 
-      const type = validTypes.has(parsed.type) ? parsed.type : cand.type || 'change';
+      // Enrichment ("add a lesson") must not reclassify a specific type down to the generic
+      // 'change' (lower TYPE_QUALITY + faster decay); keep the stored type on that downgrade.
+      let type = validTypes.has(parsed.type) ? parsed.type : (cand.type || 'change');
+      if (type === 'change' && cand.type && cand.type !== 'change') type = cand.type;
       const concepts = Array.isArray(parsed.concepts) ? parsed.concepts.slice(0, 10) : [];
       const facts = Array.isArray(parsed.facts) ? parsed.facts.slice(0, 10) : [];
       // Preserve-on-empty: wide-scope candidates can already carry concepts/facts/aliases
@@ -227,7 +240,10 @@ search_aliases: 2-6 alternative search terms (include CJK if applicable).`;
         ? parsed.search_aliases.slice(0, 6).join(' ') : (cand.search_aliases || null);
       const title = truncate(scrubSecrets(parsed.title || ''), 120);
       const narrative = truncate(scrubSecrets(parsed.narrative || cand.narrative || ''), 500);
-      const importance = clampImportance(parsed.importance);
+      // Floor at the stored importance: re-enrich adds a lesson, it must never silently downgrade
+      // a user-set/promoted importance (the UPDATE also sets optimized_at → the loss is permanent).
+      // Upgrades are still honored.
+      const importance = Math.max(clampImportance(parsed.importance), cand.importance || 1);
 
       const bigramText = cjkBigrams((title || '') + ' ' + (narrative || ''));
       const textField = [conceptsText, factsText, searchAliases || '', bigramText].filter(Boolean).join(' ');
@@ -250,7 +266,7 @@ search_aliases: 2-6 alternative search terms (include CJK if applicable).`;
       `).run(type, safe.title, safe.narrative, safe.concepts, safe.facts, safe.text,
         importance, safe.lesson_learned, safe.search_aliases, minhashSig, Date.now(), cand.id);
 
-      rebuildVector(db, cand.id, [title, narrative, conceptsText]);
+      rebuildVector(db, cand.id, { title, narrative, concepts: conceptsText, lesson_learned: safe.lesson_learned, search_aliases: safe.search_aliases });
 
       processed++;
     } catch (e) {
@@ -282,7 +298,12 @@ export function _normalizeGateOpen(last, now) {
   return now - epoch >= NORMALIZE_INTERVAL_MS;
 }
 
-export function shouldRunNormalize() {
+export function shouldRunNormalize(project = null) {
+  // The 7-day gate rate-limits the UNSCOPED whole-store normalize. An explicit --project is
+  // targeted work: it must not be blocked by a prior global (or other-project) run, and it
+  // does not advance the shared timer (see executeNormalize). Without this, `optimize --run
+  // --task normalize --project B` returned skipped(gate) for 7 days if ANY project had run.
+  if (project) return true;
   try {
     const last = JSON.parse(readFileSync(NORMALIZE_GATE_FILE, 'utf8'));
     return _normalizeGateOpen(last, Date.now());
@@ -357,7 +378,7 @@ export function applyNormalization(db, groups, { project = null } = {}) {
   // contamination the --project flag was added to prevent. NULL → all projects (legacy
   // unscoped run), matching the search-engine `(? IS NULL OR project = ?)` idiom.
   const rows = db.prepare(`
-    SELECT id, concepts, search_aliases FROM observations
+    SELECT id, title, narrative, concepts, search_aliases, lesson_learned FROM observations
     WHERE COALESCE(compressed_into, 0) = 0
       AND concepts IS NOT NULL AND concepts != ''
       AND (? IS NULL OR project = ?)
@@ -390,6 +411,9 @@ export function applyNormalization(db, groups, { project = null } = {}) {
         search_aliases: newAliases,
       });
       updateStmt.run(safe.concepts, safe.search_aliases, Date.now(), row.id);
+      // V-F3: normalize mutated concepts + search_aliases (both vector fields) — rebuild the
+      // vector so it reflects the canonicalized terms (no-op when the vector arm is disabled).
+      rebuildVector(db, row.id, { title: row.title, narrative: row.narrative, concepts: safe.concepts, search_aliases: safe.search_aliases, lesson_learned: row.lesson_learned });
       updated++;
     }
   }
@@ -399,7 +423,7 @@ export function applyNormalization(db, groups, { project = null } = {}) {
 }
 
 export async function executeNormalize(db, force = false, { project } = {}) {
-  if (!force && !shouldRunNormalize()) return { skipped: true, reason: 'gate' };
+  if (!force && !shouldRunNormalize(project)) return { skipped: true, reason: 'gate' };
 
   const concepts = extractUniqueConcepts(db, 500, { project });
   if (concepts.length < 5) return { skipped: true, reason: 'too few concepts' };
@@ -409,7 +433,10 @@ export async function executeNormalize(db, force = false, { project } = {}) {
 
   const result = applyNormalization(db, groups, { project });
 
-  try { writeFileSync(NORMALIZE_GATE_FILE, JSON.stringify({ epoch: Date.now() })); } catch {}
+  // Only the UNSCOPED (whole-store) run advances the shared 7-day gate. A project-scoped run
+  // must not reset the global timer (it never consulted it — shouldRunNormalize(project) is
+  // always open), or one `--project X` run would silently block the next global normalize.
+  if (!project) { try { writeFileSync(NORMALIZE_GATE_FILE, JSON.stringify({ epoch: Date.now() })); } catch { /* best-effort */ } }
 
   return { processed: result.updated, groups: groups.length };
 }
@@ -425,7 +452,7 @@ export function findMergeCandidates(db, maxClusters = 5, { project } = {}) {
   const cutoff = Date.now() - MERGE_TIME_WINDOW_MS;
   const projectClause = project ? 'AND project = ?' : '';
   const stmt = db.prepare(`
-    SELECT id, title, narrative, project, type, access_count, importance, created_at_epoch, minhash_sig, lesson_learned
+    SELECT id, title, narrative, project, type, access_count, importance, created_at_epoch, minhash_sig, lesson_learned, concepts, facts
     FROM observations
     WHERE COALESCE(compressed_into, 0) = 0
       AND superseded_at IS NULL
@@ -512,12 +539,15 @@ Return ONLY valid JSON:
 
     const concepts = Array.isArray(parsed.merged_concepts) ? parsed.merged_concepts.slice(0, 10) : [];
     const facts = Array.isArray(parsed.merged_facts) ? parsed.merged_facts.slice(0, 10) : [];
-    const conceptsText = concepts.join(' ');
-    const factsText = facts.join(' ');
+    // Preserve-on-empty (mirror the merged_lesson guard below + the re-enrich path): the merge
+    // overwrites the keeper in place, so a partial LLM response that omits these must fall back to
+    // the keeper's own values, not blank its live concepts/facts (findMergeCandidates now selects them).
+    const conceptsText = concepts.length ? concepts.join(' ') : (keeper.concepts || '');
+    const factsText = facts.length ? facts.join(' ') : (keeper.facts || '');
     // Scrub BEFORE truncate (see re-enrich note): keep the boundary cut on
     // already-scrubbed text so a straddling secret can't leak a sub-floor head.
     const title = truncate(scrubSecrets(parsed.merged_title || ''), 120);
-    const narrative = truncate(scrubSecrets(parsed.merged_narrative || ''), 800);
+    const narrative = truncate(scrubSecrets(parsed.merged_narrative || keeper.narrative || ''), 800);
     // Preserve-on-empty. The merge overwrites the keeper in place and hides every non-keeper
     // member (compressed_into=keeper.id), so if the LLM returns merged_lesson:null (the prompt
     // at :429 explicitly permits it) every cluster lesson would leave all live surfaces at once
@@ -581,7 +611,7 @@ Return ONLY valid JSON:
         .run(keeper.id, ...otherIds);
     })();
 
-    rebuildVector(db, keeper.id, [title, narrative, conceptsText]);
+    rebuildVector(db, keeper.id, { title, narrative, concepts: conceptsText, lesson_learned: lessonLearned, search_aliases: keeper.search_aliases });
 
     debugLog('DEBUG', 'llm-optimize', `merged ${cluster.length} observations into #${keeper.id}`);
     return { merged: true, keeperId: keeper.id, mergedCount: others.length };
@@ -785,7 +815,7 @@ JSON: {"title":"descriptive summary ≤120 chars","narrative":"comprehensive sum
       return sId;
     })();
 
-    rebuildVector(db, summaryId, [title, narrative, conceptsText]);
+    rebuildVector(db, summaryId, { title, narrative, concepts: conceptsText });
 
     debugLog('DEBUG', 'llm-optimize', `smart-compressed ${observations.length} observations into #${summaryId}`);
     return { compressed: true, summaryId, count: observations.length };
@@ -837,7 +867,7 @@ export function optimizePreview(db, { project, detail = false } = {}) {
   const reenrichAliases = findReenrichCandidates(db, 5000, { scope: 'aliases', project }).length;
 
   const concepts = extractUniqueConcepts(db, 500, { project });
-  const normalizeReady = shouldRunNormalize() && concepts.length >= 5;
+  const normalizeReady = shouldRunNormalize(project) && concepts.length >= 5;
 
   const mergeClusters = findMergeCandidates(db, 50, { project });
   const clusterMerge = mergeClusters.length;
@@ -851,7 +881,7 @@ export function optimizePreview(db, { project, detail = false } = {}) {
     reenrichWide,
     reenrichAliases,
     normalize: normalizeReady ? concepts.length : 0,
-    normalizeGateOpen: shouldRunNormalize(),
+    normalizeGateOpen: shouldRunNormalize(project),
     clusterMerge,
     smartCompress,
     total: reenrich + (normalizeReady ? 1 : 0) + clusterMerge + smartCompress,

package/hook-shared.mjs

@@ -98,7 +98,9 @@ export function sweepOrphanEpisodeFiles(runtimeDir, { ageMs = ORPHAN_EPISODE_AGE
   const readsCutoff = now - readsAgeMs;
   let count = 0;
   for (const f of entries) {
-    const isEpisode = f.startsWith('ep-flush-') || f.startsWith('pending-');
+    // `.claim-` = handleStop's lock-contended fallback claim file (ep-<project>.json.claim-<pid>-<ts>),
+    // which leaks if the process dies between rename and unlink; sweep it on the same 1h cutoff.
+    const isEpisode = f.startsWith('ep-flush-') || f.startsWith('pending-') || f.includes('.claim-');
     const isReads = f.startsWith('reads-') && f.endsWith('.txt');
     if (!isEpisode && !isReads) continue;
     const full = join(runtimeDir, f);

package/hook.mjs

@@ -484,6 +484,10 @@ async function handleStop() {
           for (const sub of planEpisodeFlush(episode)) {
             if (!sub.sessionId) sub.sessionId = sessionId;
             if (!sub.project) sub.project = project;
+            // Per-sub significance gate — parity with flushEpisodeGroup. The whole-episode check
+            // above can pass while an interleaved concurrent-session sub is pure noise (e.g. a lone
+            // Read); without this the fallback persists that noise sub AND spawns an LLM worker for it.
+            if (!episodeHasSignificantContent(sub)) continue;
             try {
               const obs = buildImmediateObservation(sub);
               const id = saveObservation(obs, sub.project, sub.sessionId);
@@ -1412,7 +1416,14 @@ async function handleUserPrompt() {
     );
 
     // Cross-session handoff injection (first 3 prompts window, before semantic memory).
-    if (promptNumber <= 3) {
+    // prompt_counter is project-scoped (shared across concurrent same-project CC sessions), so a
+    // parallel session would start past the window and never get its handoff injected. Count THIS
+    // cc_session's own prompts instead (the current one is already inserted above); legacy null cc
+    // id falls back to the shared counter.
+    const windowPos = ccSessionId
+      ? (db.prepare('SELECT COUNT(*) c FROM user_prompts WHERE cc_session_id = ?').get(ccSessionId)?.c || promptNumber)
+      : promptNumber;
+    if (windowPos <= 3) {
       try {
         if (detectContinuationIntent(db, promptText, project, ccSessionId)) {
           const picked = pickHandoffToInject(db, project, ccSessionId);

package/install.mjs

@@ -1688,12 +1688,18 @@ async function doctor() {
 
 // ─── Settings helpers ───────────────────────────────────────────────────────
 
-function isMemHook(cfg) {
+// Identify a settings hook as one of OURS (to replace on install / strip on uninstall).
+// Must be tight: the old `hook.mjs` + event-word test matched a user's OWN generic hook
+// (`node ~/.config/hook.mjs session-start`) and install/uninstall silently deleted it.
+// The launcher marker (`hook-launcher.mjs`, which every Node hook routes through since v2.84)
+// replaces that clause; the product-name substring (our install-dir / legacy-direct hooks)
+// and the bash prefilter round out the real markers.
+export function isMemHook(cfg) {
   if (!cfg.hooks) return false;
   return cfg.hooks.some(h => {
     const cmd = h.command || '';
     return cmd.includes('claude-mem-lite') ||
-      (cmd.includes('hook.mjs') && /\b(session-start|stop|user-prompt|pre-tool-use)\b/.test(cmd)) ||
+      cmd.includes('hook-launcher.mjs') ||
       cmd.includes('scripts/post-tool-use.sh');
   });
 }

package/lib/maintain-core.mjs

@@ -13,7 +13,7 @@
 //   { projectFilter: 'AND project = ?' | '', baseParams: [project?] , staleAge, opCap }
 
 import { COMPRESSED_PENDING_PURGE, computeMinHash, estimateJaccardFromMinHash, jaccardSimilarity } from '../utils.mjs';
-import { rebuildVocabulary, computeVector, _resetVocabCache, vectorsEnabled } from '../tfidf.mjs';
+import { rebuildVocabulary, computeVector, _resetVocabCache, vectorsEnabled, vecTextForRow } from '../tfidf.mjs';
 import { DEDUP_JACCARD_THRESHOLD, MINHASH_PRE_THRESHOLD as MINHASH_PRE_THRESHOLD_SRC, FUZZY_DEDUP_THRESHOLD, FUZZY_BODY_THRESHOLD, MINHASH_PREFILTER } from './dedup-constants.mjs';
 
 export const STALE_AGE_MS = 30 * 86400000;
@@ -397,10 +397,15 @@ export function maintenanceStats(db, { projectFilter, baseParams, staleAge }) {
       -- the scan stat previews what decay will mark idle, and decay protects
       -- injected rows. Omitting it over-counted "stale" by the injected-but-decayed
       -- rows decay never touches (e.g. demote_pinned's output: imp=1 but inj>0).
+      -- lesson_learned guard mirrors decayAndMarkIdle (:188) / cleanupBroken (:153): those
+      -- ops NEVER touch a lesson-bearing row ("lessons never auto-GC"), so the scan preview
+      -- must exclude them too or it over-forecasts "Stale"/"Broken" vs what execute does.
       COALESCE(SUM(CASE WHEN COALESCE(importance, 1) = 1 AND COALESCE(access_count, 0) = 0
                     AND COALESCE(injection_count, 0) = 0
+                    AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
                     AND created_at_epoch < ? THEN 1 ELSE 0 END), 0) as stale,
       COALESCE(SUM(CASE WHEN (title IS NULL OR title = '') AND (narrative IS NULL OR narrative = '')
+                    AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
                THEN 1 ELSE 0 END), 0) as broken,
       COALESCE(SUM(CASE WHEN COALESCE(access_count, 0) > 3 AND COALESCE(importance, 1) < 3
                THEN 1 ELSE 0 END), 0) as boostable,
@@ -423,7 +428,7 @@ export function rebuildVectors(db) {
   const vocab = rebuildVocabulary(db);
   if (!vocab) return { ok: false, reason: 'no observations to build vocabulary from' };
   const allObs = db.prepare(`
-    SELECT id, title, narrative, concepts FROM observations
+    SELECT id, title, narrative, concepts, lesson_learned, search_aliases FROM observations
     WHERE COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL
   `).all();
   let updated = 0;
@@ -432,8 +437,7 @@ export function rebuildVectors(db) {
   db.transaction(() => {
     db.prepare('DELETE FROM observation_vectors').run();
     for (const obs of allObs) {
-      const text = [obs.title || '', obs.narrative || '', obs.concepts || ''].filter(Boolean).join(' ');
-      const vec = computeVector(text, vocab);
+      const vec = computeVector(vecTextForRow(obs), vocab);
       if (vec) {
         insertStmt.run(obs.id, Buffer.from(vec.buffer), vocab.version, now);
         updated++;

package/lib/search-core.mjs

@@ -54,6 +54,27 @@ export function parseDuration(raw) {
   return { ok: true, ms: n * DURATION_UNIT_MS[m[2].toLowerCase()] };
 }
 
+/**
+ * Parse one from/to bound to epoch ms. A bare `YYYY-MM-DD` is the user's LOCAL
+ * calendar day (created_at_epoch is Date.now() = local wall-clock), so it must be
+ * built in local time — `new Date('YYYY-MM-DD')` parses as UTC midnight and shifts the
+ * boundary by the tz offset (8h for the UTC+8 base), silently dropping early-morning
+ * rows and leaking the next day's early hours. `endOfDay` extends a date-only bound to
+ * 23:59:59.999 local (the inclusive `--to` day). Full ISO 8601 (with time/offset) is
+ * parsed as-is, honoring any explicit zone. Out-of-range date-only strings return NaN so
+ * the caller's isNaN guard rejects them (matches the old UTC parse's strict Invalid Date).
+ */
+function parseCalendarBound(raw, endOfDay) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+    const [y, m, d] = raw.split('-').map(Number);
+    const dt = endOfDay ? new Date(y, m - 1, d, 23, 59, 59, 999) : new Date(y, m - 1, d, 0, 0, 0, 0);
+    // new Date(2026, 12, 45) silently rolls over; reject so 2026-13-45 fails like before.
+    if (dt.getFullYear() !== y || dt.getMonth() !== m - 1 || dt.getDate() !== d) return NaN;
+    return dt.getTime();
+  }
+  return new Date(raw).getTime();
+}
+
 /**
  * Parse from/to date bounds to epoch ms. Date-only `to` (YYYY-MM-DD) extends
  * to end-of-day so "to 2026-06-12" includes that day's rows. An optional
@@ -63,11 +84,8 @@ export function parseDuration(raw) {
  *         | { ok: false, bad: 'from'|'to'|'since', value: string }}
  */
 export function parseDateBounds(fromRaw, toRaw, sinceRaw = null, now = Date.now()) {
-  let epochFrom = fromRaw ? new Date(fromRaw).getTime() : null;
-  let epochTo = toRaw ? new Date(toRaw).getTime() : null;
-  if (epochTo !== null && toRaw && /^\d{4}-\d{2}-\d{2}$/.test(toRaw)) {
-    epochTo += 86400000 - 1; // extend to 23:59:59.999
-  }
+  let epochFrom = fromRaw ? parseCalendarBound(fromRaw, false) : null;
+  const epochTo = toRaw ? parseCalendarBound(toRaw, true) : null;
   if (epochFrom !== null && isNaN(epochFrom)) return { ok: false, bad: 'from', value: fromRaw };
   if (epochTo !== null && isNaN(epochTo)) return { ok: false, bad: 'to', value: toRaw };
   if (sinceRaw) {

package/lib/timeline-core.mjs

@@ -17,11 +17,11 @@ import { sanitizeFtsQuery } from '../utils.mjs';
 
 const TIMELINE_COLS = 'id, type, title, subtitle, project, created_at, created_at_epoch';
 
-/** Nearest non-compressed observation to `epoch` (optionally project-scoped). */
+/** Nearest live (non-compressed, non-superseded) observation to `epoch`. */
 function nearestObservation(db, epoch, project) {
   return db.prepare(`
     SELECT id FROM observations
-    WHERE COALESCE(compressed_into, 0) = 0 ${project ? 'AND project = ?' : ''}
+    WHERE COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL ${project ? 'AND project = ?' : ''}
     ORDER BY ABS(created_at_epoch - ?) ASC LIMIT 1
   `).get(...(project ? [project, epoch] : [epoch]));
 }
@@ -56,7 +56,7 @@ export function resolveAnchorToken(db, rawAnchor, { project = null } = {}) {
   // Bare "#N" or "N" — observation first. Route compressed obs to its live
   // parent so the window (which filters compressed) isn't shown around a dead
   // record; negative sentinels (-1 dropped, -2 pending purge) have no parent.
-  const obsRow = db.prepare('SELECT compressed_into FROM observations WHERE id = ?').get(parsed.id);
+  const obsRow = db.prepare('SELECT compressed_into, superseded_at, superseded_by FROM observations WHERE id = ?').get(parsed.id);
   if (obsRow) {
     const ci = obsRow.compressed_into;
     if (ci && ci > 0) {
@@ -65,6 +65,16 @@ export function resolveAnchorToken(db, rawAnchor, { project = null } = {}) {
     if (ci && ci < 0) {
       return { ok: false, error: { code: 'compressed-pruned', id: parsed.id } };
     }
+    // Superseded obs → hop to its live successor, mirroring compressed→parent. A
+    // superseded row is dropped from every other read path (and from the before/after
+    // window legs below), so anchoring ON it would surface a dead record. superseded_by
+    // is polymorphic: a numeric obs id for explicit supersession (save-observation), or a
+    // string marker ('auto-dedup'/'auto-dedup-fuzzy') for hook auto-dedup — only the
+    // numeric case has a successor to redirect to, so guard on `typeof … number` (not
+    // `> 0`, which a string sentinel would silently pass as NaN→false anyway but reads wrong).
+    if (obsRow.superseded_at !== null && typeof obsRow.superseded_by === 'number' && obsRow.superseded_by > 0) {
+      return { ok: true, anchorId: obsRow.superseded_by, anchorNote: `(anchored to #${obsRow.superseded_by}, #${parsed.id} was superseded by it)` };
+    }
     return { ok: true, anchorId: parsed.id, anchorNote: null };
   }
 
@@ -138,10 +148,12 @@ export function resolveQueryAnchor(db, queryStr, { project = null } = {}) {
   };
 }
 
-/** No-anchor fallback: most recent non-compressed observations, newest first. */
+/** No-anchor fallback: most recent live (non-compressed, non-superseded) obs, newest first. */
 export function fetchRecentTimeline(db, { project = null, limit }) {
-  const compressedFilter = 'COALESCE(compressed_into, 0) = 0';
-  const where = project ? `WHERE ${compressedFilter} AND project = ?` : `WHERE ${compressedFilter}`;
+  // superseded_at IS NULL mirrors the before/after window legs (fetchTimelineWindow) and
+  // every other read path — a superseded row must not lead the "most recent" timeline.
+  const liveFilter = 'COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL';
+  const where = project ? `WHERE ${liveFilter} AND project = ?` : `WHERE ${liveFilter}`;
   const params = project ? [project, limit] : [limit];
   return db.prepare(`
     SELECT ${TIMELINE_COLS}

package/mem-cli.mjs

@@ -1569,7 +1569,10 @@ function cmdUpdate(db, args) {
     updates.push('lesson_learned = ?');
     params.push(scrubSecrets(rawLesson));
   }
-  if (flags.concepts !== undefined) { updates.push('concepts = ?'); params.push(flags.concepts); }
+  // Scrub like the sibling text fields above (title/narrative/lesson) and the MCP twin
+  // mem_update — concepts is a scrub-target + FTS-indexed column, so a raw secret here
+  // lands searchable + exportable (rebuildObservationDerived folds it into `text`).
+  if (flags.concepts !== undefined) { updates.push('concepts = ?'); params.push(scrubSecrets(flags.concepts)); }
 
   if (updates.length === 0) {
     fail('[mem] No fields to update. Use --title, --type, --importance, --lesson/--lesson-learned, --narrative, --concepts');
@@ -1769,8 +1772,16 @@ function cmdRestore(db, argv) {
       // 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.
+      // Scrub the FTS-indexed text fields on the way in — the sibling ingest paths
+      // (import-jsonl, compress-core) scrub as defense-in-depth, and restore is the only
+      // rewrite path that skipped it. A backup made before a SECRET_PATTERNS entry existed
+      // would otherwise re-index an old secret in facts/concepts even though narrative
+      // (routed through saveObservation) gets re-scrubbed. files_read/branch are
+      // paths/identifiers, not scrub-target text — left as-is.
       signalUpdate.run(
-        r.subtitle || '', r.concepts || '', r.facts || '', r.search_aliases ?? null, r.files_read || '[]', r.branch ?? null,
+        scrubSecrets(r.subtitle || ''), scrubSecrets(r.concepts || ''), scrubSecrets(r.facts || ''),
+        r.search_aliases === null || r.search_aliases === undefined ? null : scrubSecrets(r.search_aliases),
+        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,
@@ -2239,7 +2250,22 @@ function cmdRegistry(_memDb, args) {
       const name = flags.name;
       const resourceType = flags['resource-type'];
       if (!name || !resourceType) { fail('[mem] Usage: claude-mem-lite registry import --name N --resource-type skill|agent [--invocation-name I] [--capability-summary S]'); return; }
-      const fields = { name, type: resourceType, status: 'active', source: flags.source || 'user' };
+      // Validate --source against its CHECK enum (parity with memRegistrySchema.source on MCP):
+      // an invalid value otherwise reaches the INSERT and throws a raw SqliteError stacktrace
+      // (the dispatcher's catch only special-cases SQLITE_BUSY/LOCKED).
+      if (flags.source && !new Set(['preinstalled', 'user', 'github']).has(flags.source)) {
+        fail(`[mem] Invalid --source "${flags.source}". Valid: preinstalled, user, github`);
+        return;
+      }
+      // Preserve provenance on a metadata-only re-import: default source to 'user' only for
+      // a genuinely NEW resource. Re-importing an existing github/preinstalled row without
+      // --source must not flip it to 'user' (which also mis-grants the user-source rank boost).
+      let source = flags.source;
+      if (!source) {
+        const existing = rdb.prepare('SELECT source FROM resources WHERE type = ? AND name = ?').get(resourceType, name);
+        source = existing ? existing.source : 'user';
+      }
+      const fields = { name, type: resourceType, status: 'active', source };
       for (const f of ['repo-url', 'local-path', 'invocation-name', 'intent-tags', 'domain-tags', 'trigger-patterns', 'capability-summary', 'keywords', 'tech-stack', 'use-cases']) {
         const camel = f.replace(/-([a-z])/g, (_, c) => '_' + c);
         fields[camel] = flags[f] || '';

package/nlp.mjs

@@ -314,6 +314,16 @@ export function sanitizeFtsQuery(query) {
             if (bg && !isCjkNoiseBigram(bg) && !matched.has(bg)) expandedTokens.push(bg);
           }
         }
+        // Preserve embedded Latin/English identifiers glued into the CJK token — e.g. the
+        // "redis" in "redis缓存问题". extractCjkKeywords + cjkBigrams only see CJK runs, so
+        // without this the Latin anchor (often the single most precise term — a proper noun
+        // like redis/grafana/oauth with no CJK synonym) was dropped, zeroing recall on
+        // whitespace-free mixed-script prompts. Mirrors registry-retriever.mjs's embedded-
+        // English extraction. Lowercased for parity with the write-path unicode61 folding.
+        for (const en of (remainder.match(/[a-zA-Z]{2,}/g) || [])) {
+          const low = en.toLowerCase();
+          if (!FTS_STOP_WORDS.has(low) && !expandedTokens.includes(low)) expandedTokens.push(low);
+        }
         continue;
       }
       // No dictionary word matched. For a PURE-CJK run, pushing the whole

package/package.json

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

@@ -233,7 +233,7 @@ export async function importFromGitHub(db, url, opts = {}) {
   // 1. Parse GitHub URL
   const parsed = parseGitHubUrl(url);
   if (!parsed) throw new Error('Invalid GitHub URL');
-  const { owner, repo, branch, path: pathFilter } = parsed;
+  const { owner, repo, branch: parsedBranch, path: pathFilter } = parsed;
 
   // 2. Fetch repo metadata (stars, forks, updated_at)
   const repoResp = await fetchFn(buildRepoUrl(owner, repo), { headers });
@@ -247,6 +247,13 @@ export async function importFromGitHub(db, url, opts = {}) {
   const repoForks = repoMeta.forks_count || 0;
   const repoUpdatedAt = repoMeta.updated_at || null;
 
+  // parseGitHubUrl defaults branch to 'main' when the URL omits `/tree/<branch>`. Prefer the
+  // repo's ACTUAL default branch in that case: a repo defaulting to master/develop/trunk
+  // otherwise 404s on a non-existent 'main' (GitHub does not redirect a missing ref), failing
+  // a URL that opens fine in the browser. An explicit `/tree/<branch>` in the URL still wins.
+  const branchExplicit = /\/tree\//.test(url.split(/[?#]/)[0]);
+  const branch = branchExplicit ? parsedBranch : (repoMeta.default_branch || parsedBranch);
+
   // 3. Fetch file tree via GitHub API (recursive)
   const treeResp = await fetchFn(buildTreeUrl(owner, repo, branch), { headers });
   if (!treeResp.ok) {

package/registry.mjs

@@ -368,9 +368,15 @@ const UPSERT_SQL = `
     indexed_at, updated_at)
   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
   ON CONFLICT(type, name) DO UPDATE SET
-    status=excluded.status, source=excluded.source, repo_url=excluded.repo_url,
+    status=excluded.status, source=excluded.source,
+    -- Preserve-on-empty (mirror the FTS text columns below): a PARTIAL re-upsert defaults
+    -- repo_url/local_path to null/'' in the caller (import is the only edit path). Clobbering
+    -- them ORPHANS the resource — mem_use/enrich read local_path (NOT NULL, so '' passes the
+    -- constraint and silently breaks reads), and the scanner needs local_path to disable it.
+    repo_url=CASE WHEN excluded.repo_url != '' THEN excluded.repo_url ELSE repo_url END,
     repo_stars=CASE WHEN excluded.repo_stars > 0 THEN excluded.repo_stars ELSE repo_stars END,
-    local_path=excluded.local_path, file_hash=excluded.file_hash,
+    local_path=CASE WHEN excluded.local_path != '' THEN excluded.local_path ELSE local_path END,
+    file_hash=excluded.file_hash,
     invocation_name=CASE WHEN excluded.invocation_name != '' THEN excluded.invocation_name ELSE invocation_name END,
     -- Preserve-on-empty (mirror repo_stars/invocation_name above): a PARTIAL re-upsert --
     -- e.g. "registry import --name X --capability-summary ...", where mem-cli defaults every

package/scripts/prompt-search-utils.mjs

@@ -164,8 +164,14 @@ export function shouldSkipByDedup(newIds, injectedFile) {
     if (count >= MAX_SESSION_INJECTIONS) return true;
     if (!ts || Date.now() - ts > DEDUP_STALE_MS) return false;
     if (!Array.isArray(prevIds) || prevIds.length === 0) return false;
-    const prevSet = new Set(prevIds);
-    const overlapCount = newIds.filter(id => prevSet.has(id)).length;
+    // Normalize both sides to strings before comparing: UPS writes obs ids as numbers
+    // (rows.map(r => r.id)) while pre-tool-recall's mergeCrossHookInjected writes them as
+    // strings (.map(String)), and both hooks SHARE this file. Without normalization
+    // Set.has(8829) misses "8829" → cross-hook dedup never fires and the same lesson
+    // double-injects within the window. (pre-tool-recall's readCrossHookInjected already
+    // String-normalizes; this brings the UPS-side reader in line.)
+    const prevSet = new Set(prevIds.map(String));
+    const overlapCount = newIds.filter(id => prevSet.has(String(id))).length;
     return overlapCount / newIds.length >= 0.8;
   } catch { return false; }
 }

package/scripts/setup.sh

@@ -39,20 +39,18 @@ fi
 mkdir -p "$DATA_DIR"
 log_ok "Data directory: $DATA_DIR"
 
-# 3. Migrate from old ~/.claude-mem/ if needed
+# 3. Legacy ~/.claude-mem/ DB is schema-v16 (no memory_session_id) with no migration bridge to
+#    the current schema — activating it FATALs on first launch ("no such column: memory_session_id")
+#    and the "! -f claude-mem-lite.db" guard would re-copy it every time the user deletes the broken
+#    DB (recovery loop). Mirror install.mjs migrateLegacyClaudeMemData: back it up (don't activate)
+#    and let a fresh DB be created. Source ~/.claude-mem/ is left intact.
 OLD_DIR="$HOME/.claude-mem"
 if [[ -f "$OLD_DIR/claude-mem.db" && ! -f "$DATA_DIR/claude-mem-lite.db" && ! -f "$DATA_DIR/claude-mem.db" ]]; then
-  log_info "Migrating data from ~/.claude-mem/ → ~/.claude-mem-lite/..."
-  if cp "$OLD_DIR/claude-mem.db" "$DATA_DIR/claude-mem-lite.db" 2>/dev/null; then
-    # Main DB copied successfully, WAL/SHM are optional
-    cp "$OLD_DIR/claude-mem.db-wal" "$DATA_DIR/claude-mem-lite.db-wal" 2>/dev/null || true
-    cp "$OLD_DIR/claude-mem.db-shm" "$DATA_DIR/claude-mem-lite.db-shm" 2>/dev/null || true
-    if [[ -d "$OLD_DIR/runtime" && ! -d "$DATA_DIR/runtime" ]]; then
-      cp -r "$OLD_DIR/runtime" "$DATA_DIR/runtime" 2>/dev/null || true
-    fi
-    log_ok "Data migrated (old ~/.claude-mem/ preserved)"
+  BACKUP="$DATA_DIR/claude-mem-lite.db.legacy-backup-$(date +%s)"
+  if cp "$OLD_DIR/claude-mem.db" "$BACKUP" 2>/dev/null; then
+    log_info "Legacy ~/.claude-mem/ DB is schema-incompatible; backed up to $(basename "$BACKUP") (a fresh DB will be created). Old ~/.claude-mem/ preserved."
   else
-    log_warn "Migration failed — using fresh database"
+    log_warn "Legacy DB backup failed — a fresh database will be created"
   fi
 fi
 

package/server.mjs

@@ -286,9 +286,15 @@ async function runSearchPipeline(db, args, { llm, rerankLlm } = {}) {
     return { ...formatSearchOutput([], args, ftsQuery, 0), escalated: false, results: [], total: 0, variants: null };
   }
 
-  // obs_type ⇒ observations-only; deep is observations-only too (deepSearch fuses
-  // hybrid-obs lists). args.type is the source filter (observations|sessions|prompts).
-  const effectiveType = deepMode === 'deep' ? 'observations' : (args.type || (args.obs_type ? 'observations' : undefined));
+  // obs_type/importance/branch/tier ⇒ observations-only; deep is observations-only too
+  // (deepSearch fuses hybrid-obs lists). args.type is the source filter
+  // (observations|sessions|prompts). Forcing obs-only for the obs-exclusive fields
+  // matches the CLI (mem-cli.mjs:177): session/prompt tables have no importance/branch/tier
+  // column, so without the force those legs return UNFILTERED and leak rows that can't be
+  // scoped to the filter (branch/importance/tier previously leaked cross-source on MCP).
+  const effectiveType = deepMode === 'deep'
+    ? 'observations'
+    : (args.type || ((args.obs_type || args.importance || args.branch || args.tier) ? 'observations' : undefined));
 
   const r = await coreRunSearchPipeline(
     {
@@ -1402,7 +1408,15 @@ server.registerTool(
       }
       const IMPORT_STRING_FIELDS = ['repo_url', 'local_path', 'invocation_name', 'intent_tags',
         'domain_tags', 'trigger_patterns', 'capability_summary', 'keywords', 'tech_stack', 'use_cases'];
-      const fields = { name: args.name, type: args.resource_type, status: 'active', source: args.source || 'user' };
+      // Preserve provenance on a metadata-only re-import (parity with cmdRegistry): default
+      // source to 'user' only for a NEW resource — a partial re-upsert of an existing
+      // github/preinstalled row without `source` must not flip it to 'user'.
+      let source = args.source;
+      if (!source) {
+        const existing = rdb.prepare('SELECT source FROM resources WHERE type = ? AND name = ?').get(args.resource_type, args.name);
+        source = existing ? existing.source : 'user';
+      }
+      const fields = { name: args.name, type: args.resource_type, status: 'active', source };
       for (const f of IMPORT_STRING_FIELDS) fields[f] = args[f] || '';
       const id = upsertResource(rdb, fields);
       return { content: [{ type: 'text', text: `Imported: ${args.resource_type}:${args.name} (id=${id})` }] };

package/source-files.mjs

@@ -198,3 +198,16 @@ export const HOOK_SCRIPT_FILES = [
   // through this wrapper so any partial-install drift heals automatically.
   'hook-launcher.mjs',
 ];
+
+// The complete set of files the release signature MUST cover: every runtime .mjs
+// (SOURCE_FILES) PLUS the executable hook scripts (copyReleaseIntoStaging installs these
+// into the live dir and they run on every hook fire). HOOK_SCRIPT_FILES were historically
+// NOT in the signed manifest, so an attacker able to PUBLISH a release — but without the
+// signing key — could swap a hook script (e.g. post-tool-use.sh / hook-launcher.mjs) while
+// every SOURCE_FILES hash still matched, and fail-closed verification would still pass →
+// RCE on the next hook fire. Keys are ROOT-relative, matching the extracted-tarball layout
+// that verifyReleaseFiles hashes against.
+export const RELEASE_SIGNED_FILES = [
+  ...SOURCE_FILES,
+  ...HOOK_SCRIPT_FILES.map(name => `scripts/${name}`),
+];

package/tfidf.mjs

@@ -207,6 +207,19 @@ let _vocabCache = null;
 /** Reset vocabulary cache (for testing). */
 export function _resetVocabCache() { _vocabCache = null; }
 
+/**
+ * Canonical TF-IDF vector text for an observation ROW (snake_case DB fields). Single source for
+ * EVERY (re)build path — save, enrich, rebuild_vectors, cluster-merge, compress, normalize — so
+ * they encode the identical field set and can't drift (V-F1). Mirrors the FTS-searchable columns
+ * incl. lesson_learned + search_aliases (finding #8). `concepts` may be an array or a string.
+ */
+export function vecTextForRow(row) {
+  if (!row) return '';
+  const concepts = Array.isArray(row.concepts) ? row.concepts.join(' ') : (row.concepts || '');
+  return [row.title || '', row.narrative || '', concepts, row.lesson_learned || '', row.search_aliases || '']
+    .filter(Boolean).join(' ');
+}
+
 /**
  * Build global vocabulary (IDF table) from all active observations.
  * @param {object} db - better-sqlite3 database
@@ -214,7 +227,7 @@ export function _resetVocabCache() { _vocabCache = null; }
  */
 export function buildVocabulary(db, { dim = VOCAB_DIM } = {}) {
   const rows = db.prepare(`
-    SELECT title, narrative, concepts FROM observations
+    SELECT title, narrative, concepts, lesson_learned, search_aliases FROM observations
     WHERE COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL
   `).all();
 
@@ -224,7 +237,10 @@ export function buildVocabulary(db, { dim = VOCAB_DIM } = {}) {
   // Count document frequency for each term
   const df = new Map();
   for (const row of rows) {
-    const text = [row.title || '', row.narrative || '', row.concepts || ''].join(' ');
+    // V-F2: include lesson_learned + search_aliases so terms living only there get a vocab
+    // dimension (else computeVector silently drops them — the exact paraphrase-bridge terms
+    // search_aliases exists to carry). Mirrors vecTextForRow's field set.
+    const text = [row.title || '', row.narrative || '', row.concepts || '', row.lesson_learned || '', row.search_aliases || ''].join(' ');
     const docTerms = new Set(tokenize(text));
     for (const term of docTerms) {
       df.set(term, (df.get(term) || 0) + 1);

package/utils.mjs

@@ -404,7 +404,13 @@ export function isMetaTriggerPrompt(text) {
     .replace(/上次(到哪了|说到哪了)?/g, '')
     .replace(/总结一下|复盘一下/g, '')
     .replace(/前面(的)?(工作|话题|讨论|内容)/g, '')
+    // R3 H-M2: control phrases named in lesson #8287 / common continuations. Phrase-anchored
+    // (or bare suffix/prefix) so a real subject that merely contains one keeps its other tokens.
+    .replace(/停了|停不下来/g, '')
+    .replace(/怎么(回事|了|样了|停的)?/g, '')
+    .replace(/再来(一次|一遍|一下)?/g, '')
     .replace(/\/?(clear|exit)\b/gi, '')
+    .replace(/\b(go on|go ahead|keep going|carry on|proceed|why(?:'?d| did) you stop)\b/gi, '')
     .replace(/\b(commit|continue|resume|push|save|restart|exit|next)\b/gi, '')
     .replace(/[，,。.!！?？:：;；()（）【】[\]\s/\\-]+/g, '')
     .trim();