claude-mem-lite 2.0.12 → 2.1.0

package/dispatch-feedback.mjs

@@ -2,7 +2,7 @@
 // Runs at Stop hook to track adoption and outcomes of recommendations
 
 import { getSessionInvocations, updateInvocation, updateResourceStats } from './registry.mjs';
-import { debugCatch } from './utils.mjs';
+import { debugCatch, EDIT_TOOLS } from './utils.mjs';
 
 // ─── Adoption Detection ──────────────────────────────────────────────────────
 
@@ -100,6 +100,30 @@ function detectAdoption(invocation, sessionEvents) {
     }
   }
 
+  // Behavioral adoption: detect usage patterns matching the recommended resource
+  const resourceLower = resource_name.toLowerCase();
+
+  // Debugging pattern: Read→Bash(error)→Read→Edit cycle
+  if (resourceLower.includes('debug') || resourceLower.includes('troubleshoot')) {
+    let hasRead = false, hasBashError = false, hasEditAfterError = false;
+    for (const e of sessionEvents) {
+      if (e.tool_name === 'Read') hasRead = true;
+      if (e.tool_name === 'Bash' && /error|fail|exception/i.test(e.tool_response || '')) hasBashError = true;
+      if (hasBashError && EDIT_TOOLS.has(e.tool_name)) hasEditAfterError = true;
+    }
+    if (hasRead && hasBashError && hasEditAfterError) return true;
+  }
+
+  // Code review pattern: Agent with 'review' in prompt/description
+  if (resourceLower.includes('review')) {
+    for (const e of sessionEvents) {
+      if (e.tool_name === 'Agent') {
+        const text = ((e.tool_input?.prompt || '') + (e.tool_input?.description || '')).toLowerCase();
+        if (text.includes('review')) return true;
+      }
+    }
+  }
+
   return false;
 }
 
@@ -127,7 +151,7 @@ function detectOutcome(sessionEvents) {
       lastErrorIndex = i;
     }
 
-    if (['Edit', 'Write', 'NotebookEdit'].includes(e.tool_name)) {
+    if (EDIT_TOOLS.has(e.tool_name)) {
       hasEdit = true;
       if (lastErrorIndex >= 0 && i > lastErrorIndex) {
         errorThenFix = true;
@@ -187,3 +211,6 @@ export async function collectFeedback(db, sessionId, sessionEvents = []) {
     debugCatch(e, 'collectFeedback');
   }
 }
+
+// Test exports
+export { detectAdoption as _detectAdoption };

package/dispatch-inject.mjs

@@ -9,6 +9,13 @@ import { DB_DIR } from './schema.mjs';
 
 const MAX_INJECTION_CHARS = 3000;
 
+/** Truncate multi-line content preserving newlines (unlike utils.truncate which flattens). */
+function truncateContent(str, max) {
+  if (!str) return '';
+  const trimmed = str.trim();
+  return trimmed.length > max ? trimmed.slice(0, max - 1) + '…' : trimmed;
+}
+
 // Allowed base directories for resource file reads (defense-in-depth)
 const ALLOWED_BASES = [
   join(homedir(), '.claude'),
@@ -79,7 +86,7 @@ function injectSkillManaged(resource) {
     } catch {}
   }
 
-  const truncatedContent = truncate(content, MAX_INJECTION_CHARS - 300);
+  const truncatedContent = truncateContent(content, MAX_INJECTION_CHARS - 300);
 
   return `[Auto-suggestion] Recommended skill for this task: "${resource.name}"
 Capability: ${truncate(resource.capability_summary, 100)}
@@ -113,7 +120,7 @@ function injectAgent(resource) {
   }
 
   if (agentDef) {
-    const truncatedDef = truncate(agentDef, MAX_INJECTION_CHARS - 300);
+    const truncatedDef = truncateContent(agentDef, MAX_INJECTION_CHARS - 300);
     return `[Auto-suggestion] A specialized agent "${resource.name}" is recommended for this task.
 Capability: ${truncate(resource.capability_summary, 100)}
 Use the Agent tool with this agent definition:

package/dispatch.mjs

@@ -6,7 +6,7 @@
 
 import { basename, join } from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { retrieveResources, buildEnhancedQuery, buildQueryFromText } from './registry-retriever.mjs';
+import { retrieveResources, buildEnhancedQuery, buildQueryFromText, DISPATCH_SYNONYMS } from './registry-retriever.mjs';
 import { renderInjection } from './dispatch-inject.mjs';
 import { updateResourceStats, recordInvocation } from './registry.mjs';
 import { callHaikuJSON } from './haiku-client.mjs';
@@ -199,6 +199,7 @@ export function extractContextSignals(event, sessionCtx = {}) {
     intent: '',          // comma-separated intent tags, primary first
     primaryIntent: '',   // first/strongest intent (for column-targeted queries)
     suppressedIntents: [], // intents detected but actively suppressed (e.g. test-run)
+    rawKeywords: [],     // domain-specific keywords not captured by intent patterns (e.g. "seo")
     techStack: '',
     action: '',
     errorDomain: '',
@@ -210,6 +211,11 @@ export function extractContextSignals(event, sessionCtx = {}) {
     signals.intent = intent;
     signals.suppressedIntents = suppressed;
     signals.primaryIntent = signals.intent.split(',')[0] || '';
+    // Extract raw domain keywords not captured by intent patterns.
+    // Intent patterns cover generic actions (test, fix, review) but miss domain
+    // topics (seo, kubernetes, oauth). These raw keywords supplement the enhanced
+    // query to ensure domain-specific resources are found.
+    signals.rawKeywords = extractRawKeywords(sessionCtx.userPrompt, signals.intent);
   }
 
   // Infer tech stack from recent files, current tool_input, or prompt text
@@ -263,7 +269,7 @@ const _WRITE_TEST_CJK = /(?:写测试|加测试|补测试|补单测|缺测试|
  * @returns {string} Comma-separated intent tags, primary intent listed first (e.g. "test,fix")
  */
 function extractIntent(prompt) {
-  if (!prompt) return '';
+  if (!prompt) return { intent: '', suppressed: [] };
   // English patterns — use trailing-optional boundaries for verb conjugations:
   //   \b prefix ensures word start, but many suffixed forms (debugging, refactoring, deployed)
   //   fail with trailing \b. Use \b...\w* for words that commonly have suffixes.
@@ -291,6 +297,9 @@ function extractIntent(prompt) {
     [/\b(perf|performance|optimiz\w*|fast\w*|slow\w*|speed\w*|latency|bottleneck|laggy)\b/i, 'fast'],
     [/\b(lint\w*|format\w*|style|prettier|eslint|biome|stylelint)\b/i, 'lint'],
     // ── Generic / overloaded (easily confused with domain terms) ──
+    // Note: bare "design" intentionally excluded — too ambiguous ("design database" vs "design UI").
+    // Only UI-specific keywords trigger design intent. Prompts like "design the homepage" without
+    // UI terms will rely on text-based FTS5 fallback rather than intent matching.
     [/\b(ui|ux|frontend|css|tailwind|responsive|layout|theme|component)\b/i, 'design'],
     // ── Chinese patterns ──
     [/(测试|写测试|单测|单元测试|用例|覆盖率)/, 'test'],
@@ -363,7 +372,53 @@ function extractIntent(prompt) {
 }
 
 /** Exported for testing. */
-export { NEGATION_EN as _NEGATION_EN, NEGATION_CJK as _NEGATION_CJK };
+export { NEGATION_EN as _NEGATION_EN, NEGATION_CJK as _NEGATION_CJK, reRankByKeywords as _reRankByKeywords, applyAdoptionDecay as _applyAdoptionDecay, passesConfidenceGate as _passesConfidenceGate };
+
+// Stop words for raw keyword extraction.
+// Includes common English stop words + action verbs already covered by intent patterns.
+// Domain-specific technical terms (seo, kubernetes, react, etc.) pass through.
+const RAW_KW_STOP = new Set([
+  // Standard English stop words
+  'the', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had',
+  'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might',
+  'can', 'shall', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by',
+  'from', 'as', 'into', 'about', 'and', 'or', 'but', 'not', 'no', 'this',
+  'that', 'it', 'its', 'my', 'your', 'me', 'us', 'you', 'he', 'she', 'we', 'they',
+  'if', 'so', 'just', 'also', 'then', 'how', 'what', 'when', 'where', 'who',
+  'use', 'using', 'need', 'want', 'check', 'look', 'help', 'please', 'let',
+  'some', 'all', 'any', 'each', 'every', 'new', 'like', 'before', 'after',
+  // Action verbs — captured by intent patterns, not domain keywords
+  'design', 'build', 'create', 'make', 'add', 'remove', 'delete', 'update',
+  'write', 'read', 'run', 'test', 'tests', 'testing', 'fix', 'debug',
+  'review', 'deploy', 'commit', 'push', 'plan', 'clean', 'refactor',
+  'find', 'get', 'set', 'show', 'list', 'change', 'move', 'copy', 'send',
+  'start', 'stop', 'open', 'close', 'save', 'load', 'install', 'setup',
+  'implement', 'configure', 'code', 'file', 'function', 'module', 'app',
+]);
+
+/**
+ * Extract raw domain keywords from prompt text that aren't captured by intent patterns.
+ * Handles embedded English words in CJK text (e.g. "seo" from "用seo技能检查下").
+ * Filters out words already covered by extracted intents to avoid duplication.
+ * @param {string} prompt User prompt text
+ * @param {string} intentStr Comma-separated intents already extracted
+ * @returns {string[]} Array of raw keywords (max 5)
+ */
+function extractRawKeywords(prompt, intentStr) {
+  if (!prompt) return [];
+  // Extract all English words (2+ chars) from the prompt
+  const words = prompt.match(/[a-zA-Z]{2,}/gi) || [];
+  const intentSet = new Set((intentStr || '').split(',').filter(Boolean));
+  const seen = new Set();
+  const result = [];
+  for (const w of words) {
+    const lower = w.toLowerCase();
+    if (lower.length < 2 || RAW_KW_STOP.has(lower) || intentSet.has(lower) || seen.has(lower)) continue;
+    seen.add(lower);
+    result.push(lower);
+  }
+  return result.slice(0, 5);
+}
 
 /**
  * Infer tech stack from file extensions.
@@ -599,6 +654,91 @@ export function isRecentlyRecommended(db, resourceId, sessionId) {
   return !!cooldownHit;
 }
 
+// ─── Keyword Re-ranking ──────────────────────────────────────────────────────
+
+/**
+ * Re-rank results to prefer resources matching rawKeywords in their intent_tags.
+ * When a user mentions domain-specific terms (e.g. "seo"), resources in that domain
+ * should rank above generic resources that only match the action intent (e.g. "review").
+ * Within each group (matching vs non-matching), original BM25 order is preserved.
+ * No-op when rawKeywords is empty.
+ * @param {object[]} results FTS5 results
+ * @param {string[]} rawKeywords Domain keywords from prompt
+ * @returns {object[]} Re-ranked results
+ */
+function reRankByKeywords(results, rawKeywords) {
+  if (!rawKeywords?.length || results.length <= 1) return results;
+  const matching = [];
+  const rest = [];
+  for (const r of results) {
+    const tags = (r.intent_tags || '').toLowerCase();
+    if (rawKeywords.some(kw => tags.includes(kw))) {
+      matching.push(r);
+    } else {
+      rest.push(r);
+    }
+  }
+  return [...matching, ...rest];
+}
+
+/**
+ * Apply adoption-rate-based score decay to penalize zombie resources.
+ * Uses Laplace-smoothed adoption rate with tiered multipliers.
+ * Cold start protection: no penalty for recommend_count < 10.
+ * @param {object[]} results FTS5 results with recommend_count/adopt_count
+ * @returns {object[]} Filtered results with decayed scores
+ */
+function applyAdoptionDecay(results) {
+  return results.map(r => {
+    const recs = r.recommend_count || 0;
+    const adopts = r.adopt_count || 0;
+    if (recs < 10) return r; // Cold start protection
+
+    const rate = (adopts + 1) / (recs + 2); // Laplace smoothing
+    let multiplier = 1.0;
+    if (recs > 100 && rate < 0.01) multiplier = 0;       // Block entirely
+    else if (recs > 50 && rate < 0.02) multiplier = 0.1;  // Heavy penalty
+    else if (recs > 20 && rate < 0.05) multiplier = 0.3;  // Light penalty
+
+    if (multiplier === 0) return null;
+    if (multiplier < 1) {
+      return { ...r, relevance: r.relevance * multiplier, _decayed: true };
+    }
+    return r;
+  }).filter(Boolean);
+}
+
+/**
+ * Gate results by confidence: require at least one intent signal
+ * to directly match the resource's intent_tags.
+ * Prevents recommendations based solely on incidental text overlap.
+ * @param {object[]} results FTS5 results
+ * @param {object} signals Context signals with intent and rawKeywords arrays
+ * @returns {object[]} Filtered results that pass the gate
+ */
+function passesConfidenceGate(results, signals) {
+  // signals.intent is a comma-separated string (e.g. "test,fix"), not an array
+  const intentTokens = typeof signals?.intent === 'string'
+    ? signals.intent.split(',').filter(Boolean)
+    : Array.isArray(signals?.intent) ? signals.intent : [];
+
+  // No structured intent → skip gate (rawKeywords match FTS5 text columns, not intent_tags)
+  if (intentTokens.length === 0) return results;
+
+  // Expand intent tokens through DISPATCH_SYNONYMS so "fast" also matches "performance", etc.
+  const rawKw = signals?.rawKeywords || [];
+  const intentSet = new Set([...intentTokens, ...rawKw]);
+  for (const token of intentTokens) {
+    const syns = DISPATCH_SYNONYMS[token];
+    if (syns) for (const s of syns) intentSet.add(s);
+  }
+
+  return results.filter(r => {
+    const tags = (r.intent_tags || '').toLowerCase().split(/[\s,]+/).filter(Boolean);
+    return tags.some(t => intentSet.has(t));
+  });
+}
+
 // ─── Main Dispatch Functions ─────────────────────────────────────────────────
 
 /**
@@ -618,7 +758,10 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
     const signals = extractContextSignals({ tool_name: '_session_start' }, { userPrompt });
     const enhancedQuery = buildEnhancedQuery(signals);
 
-    let results = enhancedQuery ? retrieveResources(db, enhancedQuery, { limit: 3, projectDomains }) : [];
+    // Fetch extra results when rawKeywords present — BM25 may rank intent-matching
+    // resources above domain-specific ones; extra headroom lets reRankByKeywords promote them.
+    const fetchLimit = signals.rawKeywords.length > 0 ? 8 : 3;
+    let results = enhancedQuery ? retrieveResources(db, enhancedQuery, { limit: fetchLimit, projectDomains }) : [];
 
     // Fallback: broad text query (catches prompts without clear intent patterns)
     if (results.length === 0) {
@@ -634,6 +777,11 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
       }
     }
 
+    results = reRankByKeywords(results, signals.rawKeywords);
+    results = applyAdoptionDecay(results);
+    results = passesConfidenceGate(results, signals);
+    results = results.slice(0, 3);
+
     let tier = 2;
 
     // Tier 3: Haiku semantic fallback (SessionStart has 10s budget)
@@ -699,7 +847,12 @@ export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
     const signals = extractContextSignals({ tool_name: '_user_prompt' }, { userPrompt });
     const enhancedQuery = buildEnhancedQuery(signals);
 
-    let results = enhancedQuery ? retrieveResources(db, enhancedQuery, { limit: 3, projectDomains }) : [];
+    // Fetch extra results when rawKeywords are present — the top-3 by BM25 may be
+    // dominated by intent synonyms (e.g. "review" expands to many code-review terms),
+    // pushing domain-specific resources (e.g. SEO) below the limit. Extra headroom
+    // lets reRankByKeywords() promote domain-matched resources to the top.
+    const fetchLimit = signals.rawKeywords.length > 0 ? 8 : 3;
+    let results = enhancedQuery ? retrieveResources(db, enhancedQuery, { limit: fetchLimit, projectDomains }) : [];
 
     // Fallback: broad text query
     if (results.length === 0) {
@@ -714,10 +867,25 @@ export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
       }
     }
 
+    // Re-rank: when rawKeywords are present, prefer resources whose intent_tags
+    // match those keywords. "帮我做一下SEO审查" → rawKeywords=["seo"] → SEO audit
+    // resources should rank above generic code-review resources.
+    results = reRankByKeywords(results, signals.rawKeywords);
+    results = applyAdoptionDecay(results);
+    results = passesConfidenceGate(results, signals);
+    results = results.slice(0, 3);
+
     if (results.length === 0) return null;
 
-    // Skip if low confidence (no Haiku fallback — stay fast)
-    if (needsHaikuDispatch(results)) return null;
+    // Skip if low confidence (no Haiku fallback — stay fast).
+    // Exception: when results match the user's raw domain keywords (e.g. "seo"),
+    // close BM25 scores indicate "multiple equally good options in the right domain"
+    // rather than "ambiguous/wrong match". Trust the domain match.
+    if (needsHaikuDispatch(results)) {
+      const hasKeywordMatch = signals.rawKeywords?.length > 0 && results.some(r =>
+        signals.rawKeywords.some(kw => (r.intent_tags || '').toLowerCase().includes(kw)));
+      if (!hasKeywordMatch) return null;
+    }
 
     // Filter by cooldown + session dedup (prevents double-recommend with SessionStart)
     const viable = sessionId
@@ -766,7 +934,9 @@ export async function dispatchOnPreToolUse(db, event, sessionCtx = {}) {
     const projectDomains = detectProjectDomains();
 
     // Tier 2: FTS5 retrieval
-    const results = retrieveResources(db, query, { limit: 3, projectDomains });
+    let results = retrieveResources(db, query, { limit: 3, projectDomains });
+    results = applyAdoptionDecay(results);
+    results = passesConfidenceGate(results, signals);
     if (results.length === 0) return null;
 
     const tier = 2; // Tier 3 disabled for PreToolUse — 2s hook timeout insufficient

package/hook-episode.mjs

@@ -3,7 +3,7 @@
 
 import { join } from 'path';
 import { readFileSync, writeFileSync, unlinkSync, readdirSync, openSync, closeSync, writeSync, renameSync, statSync, constants as fsConstants } from 'fs';
-import { inferProject } from './utils.mjs';
+import { inferProject, EDIT_TOOLS } from './utils.mjs';
 import { RUNTIME_DIR } from './hook-shared.mjs';
 
 /**
@@ -216,7 +216,7 @@ export function mergePendingEntries(episode) {
  */
 export function episodeHasSignificantContent(episode) {
   return episode.entries.some(e =>
-    ['Edit', 'Write', 'NotebookEdit'].includes(e.tool) ||
+    EDIT_TOOLS.has(e.tool) ||
     (e.tool === 'Bash' && e.isError)
   );
 }

package/hook-llm.mjs

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, unlinkSync, readdirSync } from 'fs';
 import {
   jaccardSimilarity, truncate, clampImportance, computeRuleImportance,
   inferProject, parseJsonFromLLM,
-  computeMinHash, estimateJaccardFromMinHash, debugCatch, debugLog,
+  computeMinHash, estimateJaccardFromMinHash, cjkBigrams, EDIT_TOOLS, debugCatch, debugLog,
 } from './utils.mjs';
 import { acquireLLMSlot, releaseLLMSlot } from './hook-semaphore.mjs';
 import {
@@ -16,6 +16,14 @@ import {
 
 // ─── Save Observation to DB ─────────────────────────────────────────────────
 
+/** Build the FTS5 text field from observation data (concepts + facts + CJK bigrams). */
+function buildFtsTextField(obs) {
+  const conceptsText = Array.isArray(obs.concepts) ? obs.concepts.join(' ') : '';
+  const factsText = Array.isArray(obs.facts) ? obs.facts.join(' ') : '';
+  const bigramText = cjkBigrams((obs.title || '') + ' ' + (obs.narrative || ''));
+  return { conceptsText, factsText, textField: [conceptsText, factsText, bigramText].filter(Boolean).join(' ') };
+}
+
 export function saveObservation(obs, projectOverride, sessionIdOverride, externalDb) {
   const db = externalDb || openDb();
   if (!db) return null;
@@ -58,9 +66,7 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
       }
     }
 
-    const conceptsText = Array.isArray(obs.concepts) ? obs.concepts.join(' ') : '';
-    const factsText = Array.isArray(obs.facts) ? obs.facts.join(' ') : '';
-    const textField = [conceptsText, factsText].filter(Boolean).join(' ');
+    const { conceptsText, factsText, textField } = buildFtsTextField(obs);
 
     const result = db.prepare(`
       INSERT INTO observations (memory_session_id, project, text, type, title, subtitle, narrative, concepts, facts, files_read, files_modified, importance, minhash_sig, created_at, created_at_epoch)
@@ -160,10 +166,10 @@ function linkRelatedObservations(db, savedId, obs, episode) {
 // When LLM is unavailable, build a readable title from episode metadata
 // instead of using raw makeEntryDesc output (which contains JSON stdout).
 
-function buildDegradedTitle(episode) {
+export function buildDegradedTitle(episode) {
   const files = (episode.files || []).filter(Boolean);
   const hasError = episode.entries.some(e => e.isError);
-  const hasEdit = episode.entries.some(e => ['Edit', 'Write', 'NotebookEdit'].includes(e.tool));
+  const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
 
   if (files.length > 0) {
     const names = files.map(f => basename(f)).slice(0, 3).join(', ');
@@ -270,8 +276,14 @@ importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=cr
 
   if (!obs) {
     if (!gotSlot) debugLog('WARN', 'llm-episode', 'semaphore timeout, using degraded storage');
+    // If pre-saved observation exists, LLM degraded mode doesn't need to overwrite — keep pre-saved data
+    if (episode.savedId) {
+      debugLog('DEBUG', 'llm-episode', `LLM failed but pre-saved obs #${episode.savedId} exists, keeping`);
+      try { unlinkSync(tmpFile); } catch {}
+      return;
+    }
     const hasError = episode.entries.some(e => e.isError);
-    const hasEdit = episode.entries.some(e => ['Edit', 'Write', 'NotebookEdit'].includes(e.tool));
+    const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
     const inferredType = hasError ? 'bugfix' : hasEdit ? 'change' : 'discovery';
     obs = {
       type: inferredType,
@@ -290,7 +302,30 @@ importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=cr
   if (!db) { try { unlinkSync(tmpFile); } catch {} return; }
 
   try {
-    const savedId = saveObservation(obs, episode.project, episode.sessionId, db);
+    let savedId;
+
+    if (episode.savedId && obs) {
+      // Upgrade pre-saved observation with LLM-enriched data
+      const { conceptsText, factsText, textField } = buildFtsTextField(obs);
+      const minhashSig = computeMinHash((obs.title || '') + ' ' + (obs.narrative || ''));
+      db.prepare(`
+        UPDATE observations SET type=?, title=?, subtitle=?, narrative=?, concepts=?, facts=?,
+          text=?, importance=?, files_read=?, minhash_sig=?
+        WHERE id = ?
+      `).run(
+        obs.type, truncate(obs.title, 120), obs.subtitle || '',
+        truncate(obs.narrative || '', 500),
+        conceptsText, factsText, textField,
+        obs.importance,
+        JSON.stringify(obs.filesRead || []),
+        minhashSig,
+        episode.savedId
+      );
+      savedId = episode.savedId;
+      debugLog('DEBUG', 'llm-episode', `upgraded pre-saved obs #${savedId}`);
+    } else {
+      savedId = saveObservation(obs, episode.project, episode.sessionId, db);
+    }
 
     if (savedId) {
       try {

package/hook-shared.mjs

@@ -121,6 +121,18 @@ export function spawnBackground(bgEvent, ...extraArgs) {
 
 export function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
+// ─── Injection Budget (per-session, in-memory) ──────────────────────────────
+// Limits total context injections across all hooks to prevent context bloat.
+// Reset at session-start. Each hook checks before injecting.
+
+export const MAX_INJECTIONS_PER_SESSION = 3;
+let _injectionCount = 0;
+
+export function getInjectionCount() { return _injectionCount; }
+export function incrementInjection() { _injectionCount++; }
+export function resetInjectionBudget() { _injectionCount = 0; }
+export function hasInjectionBudget() { return _injectionCount < MAX_INJECTIONS_PER_SESSION; }
+
 // ─── Tool Event Tracking (for dispatch feedback) ────────────────────────────
 // PostToolUse appends feedback-relevant tool events (Skill, Task, Edit, Write, Bash errors).
 // Stop handler reads them and passes to collectFeedback for adoption/outcome detection.

package/hook.mjs

@@ -10,7 +10,7 @@ import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statS
 import {
   truncate, typeIcon, inferProject, detectBashSignificance,
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
-  makeEntryDesc, scrubSecrets, debugCatch, debugLog, fmtTime,
+  makeEntryDesc, scrubSecrets, computeRuleImportance, EDIT_TOOLS, debugCatch, debugLog, fmtTime,
 } from './utils.mjs';
 import {
   readEpisodeRaw, episodeFile,
@@ -27,8 +27,10 @@ import {
   RESOURCE_RESCAN_INTERVAL_MS,
   sessionFile, getSessionId, createSessionId, openDb, getRegistryDb,
   closeRegistryDb, spawnBackground, appendToolEvent, readAndClearToolEvents,
+  resetInjectionBudget, hasInjectionBudget, incrementInjection,
 } from './hook-shared.mjs';
-import { handleLLMEpisode, handleLLMSummary } from './hook-llm.mjs';
+import { handleLLMEpisode, handleLLMSummary, saveObservation, buildDegradedTitle } from './hook-llm.mjs';
+import { searchRelevantMemories } from './hook-memory.mjs';
 
 // Prevent recursive hooks from background claude -p calls
 // Background workers (llm-episode, llm-summary, resource-scan) are exempt — they're ours
@@ -80,6 +82,32 @@ function flushEpisode(episode) {
     episode.filesRead = episode.filesRead || [];
   }
 
+  const isSignificant = episodeHasSignificantContent(episode);
+
+  // Immediate save: create rule-based observation for instant visibility.
+  // LLM background worker will upgrade title/narrative/importance later.
+  if (isSignificant) {
+    try {
+      const hasError = episode.entries.some(e => e.isError);
+      const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
+      const inferredType = hasError ? 'bugfix' : hasEdit ? 'change' : 'discovery';
+      const fileList = (episode.files || []).map(f => basename(f)).join(', ') || '(multiple)';
+      const obs = {
+        type: inferredType,
+        title: truncate(buildDegradedTitle(episode), 120),
+        subtitle: fileList,
+        narrative: episode.entries.map(e => e.desc).join('; '),
+        concepts: [],
+        facts: [],
+        files: episode.files,
+        filesRead: episode.filesRead || [],
+        importance: computeRuleImportance(episode),
+      };
+      const id = saveObservation(obs, episode.project, episode.sessionId);
+      if (id) episode.savedId = id;
+    } catch (e) { debugCatch(e, 'flushEpisode-immediateSave'); }
+  }
+
   // Write episode to flush file, then remove buffer AFTER spawn to prevent race
   const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
   try {
@@ -88,7 +116,7 @@ function flushEpisode(episode) {
     return;
   }
 
-  if (episodeHasSignificantContent(episode)) {
+  if (isSignificant) {
     spawnBackground('llm-episode', flushFile);
   } else {
     try { unlinkSync(flushFile); } catch {}
@@ -150,7 +178,7 @@ async function handlePostToolUse() {
     files,
     ts: Date.now(),
     isError: bashSig?.isError || false,
-    isSignificant: ['Edit', 'Write', 'NotebookEdit'].includes(tool_name) ||
+    isSignificant: EDIT_TOOLS.has(tool_name) ||
                    bashSig?.isSignificant || false,
     bashSig: bashSig || null,
   };
@@ -203,7 +231,7 @@ async function handlePostToolUse() {
     addFileToEpisode(episode, files);
 
     // Proactive file history: show past observations for files being edited
-    if (['Edit', 'Write', 'NotebookEdit'].includes(tool_name) && files.length > 0) {
+    if (EDIT_TOOLS.has(tool_name) && files.length > 0) {
       const d = getDb();
       if (d) {
         for (const f of files) {
@@ -356,6 +384,8 @@ async function handleStop() {
 // ─── SessionStart Handler + CLAUDE.md Persistence (Tier 1 A, E) ─────────────
 
 async function handleSessionStart() {
+  resetInjectionBudget();
+
   // Flush any leftover episode buffer from previous session (e.g. after /clear)
   if (acquireLock()) {
     try {
@@ -636,11 +666,12 @@ async function handleSessionStart() {
     // Dispatch: recommend skill/agent based on session context
     try {
       const rdb = getRegistryDb();
-      if (rdb) {
+      if (rdb && hasInjectionBudget()) {
         const promptCtx = latestSummary?.next_steps || '';
         const dispatchResult = await dispatchOnSessionStart(rdb, promptCtx, sessionId);
         if (dispatchResult) {
           process.stdout.write(dispatchResult + '\n');
+          incrementInjection();
         }
       }
     } catch (e) { debugCatch(e, 'handleSessionStart-dispatch'); }
@@ -693,9 +724,12 @@ async function handlePreToolUse() {
     }
   } catch {}
 
-  const injection = await dispatchOnPreToolUse(rdb, hookData, sessionCtx);
-  if (injection) {
-    process.stdout.write(injection + '\n');
+  if (hasInjectionBudget()) {
+    const injection = await dispatchOnPreToolUse(rdb, hookData, sessionCtx);
+    if (injection) {
+      process.stdout.write(injection + '\n');
+      incrementInjection();
+    }
   }
 }
 
@@ -715,11 +749,12 @@ async function handleUserPrompt() {
   const db = openDb();
   if (!db) return;
 
+  const project = inferProject();
+
   try {
     const now = new Date();
 
     // Ensure session exists (INSERT OR IGNORE avoids race condition)
-    const project = inferProject();
     db.prepare(`
       INSERT OR IGNORE INTO sdk_sessions (content_session_id, memory_session_id, project, started_at, started_at_epoch, status)
       VALUES (?, ?, ?, ?, ?, 'active')
@@ -738,6 +773,30 @@ async function handleUserPrompt() {
       counter?.prompt_counter || 1,
       now.toISOString(), now.getTime()
     );
+
+    // Semantic memory injection: search past observations for the user's prompt
+    if (hasInjectionBudget()) {
+      try {
+        const keyObs = db.prepare(`
+          SELECT id FROM observations
+          WHERE project = ? AND COALESCE(compressed_into, 0) = 0
+            AND COALESCE(importance, 1) >= 2
+          ORDER BY created_at_epoch DESC LIMIT 5
+        `).all(project);
+        const keyContextIds = keyObs.map(o => o.id);
+
+        const memories = searchRelevantMemories(db, promptText, project, keyContextIds);
+        if (memories.length > 0) {
+          const lines = ['<memory-context relevance="high">'];
+          for (const m of memories) {
+            lines.push(`- [${m.type}] ${truncate(m.title, 80)} (#${m.id})`);
+          }
+          lines.push('</memory-context>');
+          process.stdout.write(lines.join('\n') + '\n');
+          incrementInjection();
+        }
+      } catch (e) { debugCatch(e, 'handleUserPrompt-memory'); }
+    }
   } finally {
     db.close();
   }
@@ -749,10 +808,11 @@ async function handleUserPrompt() {
   // Cooldown + session dedup (invocations table) prevents double-recommending with SessionStart.
   try {
     const rdb = getRegistryDb();
-    if (rdb) {
+    if (rdb && hasInjectionBudget()) {
       const result = await dispatchOnUserPrompt(rdb, promptText, sessionId);
       if (result) {
         process.stdout.write(result + '\n');
+        incrementInjection();
       }
     }
   } catch (e) { debugCatch(e, 'handleUserPrompt-dispatch'); }

package/install.mjs

@@ -445,7 +445,7 @@ const RESOURCE_METADATA = {
     trigger_patterns: 'when user needs social media content posts or engagement strategies',
   },
   'skill:seo-audit': {
-    intent_tags: 'seo,audit,technical,analysis,crawl,performance,indexing',
+    intent_tags: 'seo,audit,technical,analysis,crawl,indexing',
     domain_tags: 'seo,audit,web',
     capability_summary: 'Comprehensive SEO audit with technical analysis crawl errors and performance checks',
     trigger_patterns: 'when user needs a comprehensive SEO audit or technical site analysis',
@@ -523,8 +523,8 @@ const RESOURCE_METADATA = {
     trigger_patterns: 'when user wants automated SEO content writing or optimization assistance',
   },
   'agent:seo-performance-agent': {
-    intent_tags: 'seo,performance,agent,speed,core-web-vitals,pagespeed',
-    domain_tags: 'seo,performance,agent',
+    intent_tags: 'seo,agent,core-web-vitals,pagespeed',
+    domain_tags: 'seo,agent',
     capability_summary: 'SEO performance monitoring agent for core web vitals and page speed analysis',
     trigger_patterns: 'when user needs automated SEO performance monitoring or speed optimization',
   },
@@ -1212,7 +1212,7 @@ async function install() {
 
   const SOURCE_FILES = [
     'server.mjs', 'server-internals.mjs', 'tool-schemas.mjs',
-    'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs',
+    'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs',
     'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs',
     'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'skill.md',
     'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.0.12",
+  "version": "2.1.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {

package/registry-retriever.mjs

@@ -5,7 +5,7 @@ import { debugCatch } from './utils.mjs';
 
 // ─── Domain Synonyms ─────────────────────────────────────────────────────────
 
-const DISPATCH_SYNONYMS = {
+export const DISPATCH_SYNONYMS = {
   // English intent synonyms
   'clean':    ['refactor', 'lint', 'format', 'organize', 'tidy', 'simplify', 'restructure', 'rewrite', 'smell', 'debt'],
   'test':     ['testing', 'unittest', 'e2e', 'coverage', 'tdd', 'qa', 'spec', 'jest', 'vitest', 'pytest', 'mocha', 'cypress', 'playwright'],
@@ -190,6 +190,18 @@ export function buildEnhancedQuery(signals) {
     }
   }
 
+  // Raw keywords from prompt: domain-specific terms not captured by intent patterns.
+  // Added as column-targeted intent_tags + literal general match (no synonym expansion).
+  // Synonym expansion is harmful for rawKeywords: "database" expanding to ORM/SQL terms
+  // would dilute BM25 precision. Literal matching is sufficient — "seo" matches "seo"
+  // directly across name, intent_tags, capability_summary, trigger_patterns.
+  if (signals.rawKeywords?.length > 0) {
+    for (const kw of signals.rawKeywords) {
+      parts.push(`intent_tags:${kw}`);
+      parts.push(kw); // literal, no synonym expansion
+    }
+  }
+
   // Add general tokens (expanded with synonyms)
   for (const t of generalTokens) {
     parts.push(expandToken(t));
@@ -205,39 +217,46 @@ export function buildEnhancedQuery(signals) {
  * @param {string} text Raw text input
  * @returns {string|null} FTS5 query string or null
  */
+const TEXT_QUERY_STOP_WORDS = new Set([
+  'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+  'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
+  'on', 'with', 'at', 'by', 'from', 'as', 'into', 'about', 'between',
+  'after', 'before', 'above', 'below', 'and', 'or', 'but', 'not', 'no',
+  'this', 'that', 'these', 'those', 'it', 'its', 'my', 'your', 'his',
+  'her', 'our', 'their', 'me', 'him', 'us', 'them', 'i', 'you', 'he',
+  'she', 'we', 'they', 'what', 'which', 'who', 'when', 'where', 'how',
+  'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some',
+  'such', 'than', 'too', 'very', 'just', 'also', 'then', 'so', 'if',
+  '的', '了', '是', '在', '我', '有', '和', '就', '不', '人', '都',
+  '一', '一个', '上', '也', '这', '那', '你', '他', '她', '它', '们',
+  '把', '让', '给', '用', '来', '去', '做', '说', '要', '会', '能',
+  '帮', '帮我', '请', '下', '吧',
+]);
+
 export function buildQueryFromText(text) {
   if (!text || typeof text !== 'string') return null;
 
-  const STOP_WORDS = new Set([
-    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-    'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
-    'on', 'with', 'at', 'by', 'from', 'as', 'into', 'about', 'between',
-    'after', 'before', 'above', 'below', 'and', 'or', 'but', 'not', 'no',
-    'this', 'that', 'these', 'those', 'it', 'its', 'my', 'your', 'his',
-    'her', 'our', 'their', 'me', 'him', 'us', 'them', 'i', 'you', 'he',
-    'she', 'we', 'they', 'what', 'which', 'who', 'when', 'where', 'how',
-    'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some',
-    'such', 'than', 'too', 'very', 'just', 'also', 'then', 'so', 'if',
-    '的', '了', '是', '在', '我', '有', '和', '就', '不', '人', '都',
-    '一', '一个', '上', '也', '这', '那', '你', '他', '她', '它', '们',
-    '把', '让', '给', '用', '来', '去', '做', '说', '要', '会', '能',
-    '帮', '帮我', '请', '下', '吧',
-  ]);
-
   const cleaned = text.replace(/[{}()[\]^~*:@#$%&]/g, ' ').trim();
 
   // Extract CJK compound words before whitespace split (Chinese has no spaces)
   const cjkTokens = extractCJKTokens(cleaned);
 
+  // Extract embedded English words from mixed CJK/Latin text.
+  // Handles "用seo技能检查下网站的seo优化问题" → extracts "seo".
+  // Whitespace split fails here because CJK text has no spaces.
+  const embeddedEnTokens = (cleaned.match(/[a-zA-Z]{2,}/g) || [])
+    .map(w => w.toLowerCase());
+
   const wsTokens = cleaned.split(/\s+/)
-    .filter(t => t.length > 1 && !STOP_WORDS.has(t.toLowerCase()) && !/^\d+$/.test(t));
+    .filter(t => t.length > 1 && !TEXT_QUERY_STOP_WORDS.has(t.toLowerCase()) && !/^\d+$/.test(t));
 
-  // Merge: CJK tokens first (high signal), then whitespace tokens, deduplicated
+  // Merge: CJK tokens first (high signal), then embedded English, then whitespace tokens, deduplicated
   const seen = new Set();
   const tokens = [];
-  for (const t of [...cjkTokens, ...wsTokens]) {
-    if (!seen.has(t)) { seen.add(t); tokens.push(t); }
+  for (const t of [...cjkTokens, ...embeddedEnTokens, ...wsTokens]) {
+    const key = t.toLowerCase();
+    if (!seen.has(key) && !TEXT_QUERY_STOP_WORDS.has(key)) { seen.add(key); tokens.push(t); }
   }
   tokens.splice(8); // Limit to 8 most relevant tokens
 

package/server.mjs

@@ -686,7 +686,10 @@ server.registerTool(
     const deletedIds = new Set(args.ids);
     const deleteTx = db.transaction(() => {
       // Clean up stale references in other observations' related_ids
-      // Use LIKE filter to avoid O(N) full-table scan — only fetch rows that may reference deleted IDs
+      // Use LIKE filter to avoid O(N) full-table scan — only fetch rows that may reference deleted IDs.
+      // NOTE: LIKE %id% has false positives (e.g. %1% matches [10], [21]). This is intentional —
+      // the LIKE is a coarse pre-filter; the JSON parse + Set.has below is the precise filter.
+      // Acceptable because observation count per user is typically <10K.
       const likeConditions = args.ids.map(() => `related_ids LIKE ?`).join(' OR ');
       const likeParams = args.ids.map(id => `%${id}%`);
       const referencing = db.prepare(`

package/utils.mjs

@@ -261,8 +261,8 @@ for (const [abbr, full] of SYNONYM_PAIRS) {
 
 // Format a term for FTS5: quote if it contains spaces, hyphens, or special chars
 function ftsToken(term) {
-  // Bare tokens are safe only if purely alphanumeric
-  if (/^[a-zA-Z0-9]+$/.test(term)) return term;
+  // Bare tokens are safe if purely alphanumeric or CJK characters
+  if (/^[a-zA-Z0-9\u4e00-\u9fff\u3400-\u4dbf]+$/.test(term)) return term;
   return `"${term.replace(/"/g, '""')}"`;
 }
 
@@ -292,10 +292,26 @@ export function sanitizeFtsQuery(query) {
   if (!cleaned) return null;
   const tokens = cleaned.split(/\s+/).filter(t => t && !/^-+$/.test(t) && !FTS5_KEYWORDS.has(t.toUpperCase()));
   if (tokens.length === 0) return null;
-  const expanded = tokens.map(t => expandToken(t));
+  // Replace single CJK character tokens with bigrams for better phrase matching.
+  // Individual CJK chars ("系","统") are too noisy; bigrams ("系统") capture compound words.
+  const bigrams = cjkBigrams(cleaned);
+  const bigramSet = new Set(bigrams ? bigrams.split(' ').filter(Boolean) : []);
+  const hasBigrams = bigramSet.size > 0;
+  const finalTokens = [];
+  const seen = new Set();
+  for (const t of tokens) {
+    // Skip single CJK characters when we have bigrams — they're subsumed by bigram tokens
+    if (hasBigrams && /^[\u4e00-\u9fff\u3400-\u4dbf]$/.test(t)) continue;
+    const expanded = expandToken(t);
+    if (!seen.has(expanded)) { seen.add(expanded); finalTokens.push(expanded); }
+  }
+  for (const bg of bigramSet) {
+    if (!seen.has(bg)) { seen.add(bg); finalTokens.push(bg); }
+  }
+  if (finalTokens.length === 0) return null;
   // FTS5 requires explicit AND after parenthesized OR groups
-  const hasGroup = expanded.some(e => e.startsWith('('));
-  return expanded.join(hasGroup ? ' AND ' : ' ');
+  const hasGroup = finalTokens.some(e => e.startsWith('('));
+  return finalTokens.join(hasGroup ? ' AND ' : ' ');
 }
 
 /**
@@ -336,11 +352,24 @@ export function clampImportance(val) {
  * @param {object} episode Episode with entries array
  * @returns {number} Rule-based importance (1, 2, or 3)
  */
+// Tools that produce file edits (used for significance detection, feedback, importance)
+export const EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
+
 export function computeRuleImportance(episode) {
   let importance = 1;
+  const toolTypes = new Set();
+  let hasErrorThenEdit = false;
+  let lastWasError = false;
+
   for (const entry of episode.entries) {
     const sig = entry.bashSig;
     const files = entry.files || [];
+    toolTypes.add(entry.tool);
+
+    // Track error→edit debug cycle pattern
+    if (lastWasError && EDIT_TOOLS.has(entry.tool)) hasErrorThenEdit = true;
+    lastWasError = entry.isError || sig?.isError;
+
     if (sig?.isError && (sig?.isTest || sig?.isBuild)) { importance = 3; break; }
     if (files.some(f => /\.(env|pem|key)$|\/auth\.|\/credential|\/password/i.test(f))) { importance = 3; break; }
     if (files.some(f => /migration|schema\.|prisma|alembic/i.test(f))) { importance = 3; break; }
@@ -349,9 +378,35 @@ export function computeRuleImportance(episode) {
     if (sig?.isDeploy && importance < 2) importance = 2;
     if (files.some(f => /\.config\.|tsconfig|Dockerfile|docker-compose|package\.json|\.yml$|\.yaml$/i.test(basename(f))) && importance < 2) importance = 2;
   }
+
+  // Tool diversity: Edit + Bash + another tool = complete dev cycle
+  if (toolTypes.size >= 3 && toolTypes.has('Edit') && importance < 2) importance = 2;
+  // Debug cycle: error followed by edit = active debugging
+  if (hasErrorThenEdit && importance < 2) importance = 2;
+  // Broad change: many files touched
+  if ((episode.files || []).length >= 5 && importance < 2) importance = 2;
+
   return importance;
 }
 
+/**
+ * Generate CJK bigrams from text for improved Chinese phrase matching in FTS5.
+ * "修复了系统崩溃" → "修复 系统 统崩 崩溃"
+ * @param {string} text Input text containing CJK characters
+ * @returns {string} Space-separated bigrams
+ */
+export function cjkBigrams(text) {
+  if (!text) return '';
+  const runs = text.match(/[\u4e00-\u9fff\u3400-\u4dbf]{2,}/g) || [];
+  const bigrams = [];
+  for (const run of runs) {
+    for (let i = 0; i < run.length - 1; i++) {
+      bigrams.push(run[i] + run[i + 1]);
+    }
+  }
+  return bigrams.join(' ');
+}
+
 // ─── Project Inference ───────────────────────────────────────────────────────
 
 /**