claude-mem-lite 2.10.7 → 2.11.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.10.7",
+  "version": "2.11.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/dispatch.mjs

@@ -6,11 +6,11 @@
 import { basename, join } from 'path';
 import { existsSync } from 'fs';
 import { retrieveResources, buildEnhancedQuery, buildQueryFromText, DISPATCH_SYNONYMS } from './registry-retriever.mjs';
-import { renderInjection, renderHint } from './dispatch-inject.mjs';
+import { renderInjection } from './dispatch-inject.mjs';
 import { updateResourceStats, recordInvocation } from './registry.mjs';
-import { debugCatch } from './utils.mjs';
-import { peekToolEvents } from './hook-shared.mjs';
-import { detectActiveSuite, shouldRecommendForStage, detectExplicitRequest, inferCurrentStage } from './dispatch-workflow.mjs';
+import { debugCatch, extractErrorKeywords, truncate, inferProject, sanitizeFtsQuery } from './utils.mjs';
+import { peekToolEvents, openDb } from './hook-shared.mjs';
+import { detectExplicitRequest } from './dispatch-workflow.mjs';
 import { detectFailurePattern } from './dispatch-patterns.mjs';
 
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -1076,112 +1076,38 @@ export async function dispatchOnSessionStart() {
 }
 
 /**
- * Dispatch on UserPromptSubmit: analyze user's actual prompt, return best resource suggestion.
- * Tier 1+2 only (no Haiku fallback) for fast response within hook timeout.
- * Cooldown + session dedup prevents double-recommending with SessionStart.
+ * Dispatch on UserPromptSubmit: only fires for explicit user requests.
+ * All ambient/proactive recommendations removed — 9.7% adoption rate showed they were noise.
+ * Users who need a skill/agent should explicitly ask ("I need X", "find me a tool for Y")
+ * or use mem_registry search directly.
  * @param {Database} db Registry database
  * @param {string} userPrompt User's prompt text
  * @param {string} [sessionId] Session identifier for dedup
  * @returns {Promise<string|null>} Injection text or null
  */
-export async function dispatchOnUserPrompt(db, userPrompt, sessionId, { sessionEvents, prevContext } = {}) {
+export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
   if (!userPrompt || !db) return null;
 
   try {
-    // 1. Explicit request → highest priority, bypass cooldown but apply adoption decay
+    // Only dispatch on explicit user requests ("I need a skill for X", "find me a tool for Y")
     const explicit = detectExplicitRequest(userPrompt);
-    if (explicit.isExplicit) {
-      const textQuery = buildQueryFromText(explicit.searchTerm);
-      if (textQuery) {
-        let explicitResults = retrieveResources(db, textQuery, { limit: 3, projectDomains: detectProjectDomains() });
-        explicitResults = filterAutoLoadedSkills(explicitResults);
-        explicitResults = filterGarbageMetadata(explicitResults);
-        explicitResults = applyAdoptionDecay(explicitResults, db);
-        if (explicitResults.length > 0) {
-          const best = explicitResults[0];
-          if (!sessionId || !isRecentlyRecommended(db, best.id, sessionId)) {
-            recordInvocation(db, { resource_id: best.id, session_id: sessionId, trigger: 'user_prompt', tier: 1, recommended: 1 });
-            updateResourceStats(db, best.id, 'recommend_count');
-            return renderInjection(best, buildRecommendReason(null, { explicit: true }));
-          }
-        }
-      }
-    }
-
-    // 2. Suite auto-flow protection
-    const events = sessionEvents || peekToolEvents();
-    const activeSuite = detectActiveSuite(events);
-
-    const projectDomains = detectProjectDomains();
-
-    // Enrich prompt with previous session context (cached at session-start).
-    // Combines project history (next_steps) with user intent for richer signal.
-    const enrichedPrompt = prevContext
-      ? `${userPrompt}\n[Previous session: ${prevContext}]`
-      : userPrompt;
+    if (!explicit.isExplicit) return null;
 
-    // Intent-aware enhanced query (column-targeted)
-    const signals = extractContextSignals({ tool_name: '_user_prompt' }, { userPrompt: enrichedPrompt });
-
-    // Check if active suite covers the current stage
-    if (activeSuite) {
-      const currentStage = inferCurrentStage(signals.primaryIntent, activeSuite, signals.suppressedIntents);
-      if (currentStage) {
-        const { shouldRecommend } = shouldRecommendForStage(activeSuite, currentStage);
-        if (!shouldRecommend) return null;
-      }
-    }
-
-    // 3. Normal FTS flow
-    const enhancedQuery = buildEnhancedQuery(signals);
-
-    // 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) {
-      const textQuery = buildQueryFromText(userPrompt);
-      if (!textQuery) return null;
-      results = retrieveResources(db, textQuery, { limit: 3, projectDomains });
-      if (signals.suppressedIntents.length > 0) {
-        results = results.filter(r => {
-          const tags = (r.intent_tags || '').toLowerCase().split(/[\s,]+/);
-          return !signals.suppressedIntents.some(s => tags.includes(s));
-        });
-      }
-    }
-
-    results = postProcessResults(results, signals, db);
+    const textQuery = buildQueryFromText(explicit.searchTerm);
+    if (!textQuery) return null;
 
+    let results = retrieveResources(db, textQuery, { limit: 3, projectDomains: detectProjectDomains() });
+    results = filterAutoLoadedSkills(results);
+    results = filterGarbageMetadata(results);
+    results = applyAdoptionDecay(results, db);
     if (results.length === 0) return null;
 
-    // Filter by cooldown + session dedup (hoisted cap + cooldown avoids N queries)
-    if (sessionId && isSessionCapped(db, sessionId)) return null;
-    const cooldown = getAdaptiveCooldown(db);
-    const viable = sessionId
-      ? results.filter(r => !isRecentlyRecommended(db, r.id, sessionId, { skipCapCheck: true, cooldown }))
-      : results;
-    if (viable.length === 0) return null;
-
-    const best = viable[0];
-
-    recordInvocation(db, {
-      resource_id: best.id,
-      session_id: sessionId || null,
-      trigger: 'user_prompt',
-      tier: 2,
-      recommended: 1,
-    });
-    updateResourceStats(db, best.id, 'recommend_count');
+    const best = results[0];
+    if (sessionId && isRecentlyRecommended(db, best.id, sessionId)) return null;
 
-    const tier = decideTier(best, signals);
-    if (tier === 'silent') return null;
-    if (tier === 'hint') return renderHint(best);
-    return renderInjection(best, buildRecommendReason(signals));
+    recordInvocation(db, { resource_id: best.id, session_id: sessionId, trigger: 'user_prompt', tier: 1, recommended: 1 });
+    updateResourceStats(db, best.id, 'recommend_count');
+    return renderInjection(best, buildRecommendReason(null, { explicit: true }));
   } catch (e) {
     debugCatch(e, 'dispatchOnUserPrompt');
     return null;
@@ -1189,82 +1115,105 @@ export async function dispatchOnUserPrompt(db, userPrompt, sessionId, { sessionE
 }
 
 /**
- * Dispatch on PreToolUse: filter, analyze, and optionally recommend.
- * @param {Database} db Registry database
+ * Dispatch on PreToolUse: error recall only.
+ * When Claude is stuck in an error loop, search past observations for similar errors.
+ * No ambient resource recommendations — only inject past solutions.
+ * @param {Database} db Registry database (unused, kept for API compat)
  * @param {object} event Hook event data
- * @param {object} [sessionCtx] Session context (userPrompt, recentFiles, sessionId)
+ * @param {object} [sessionCtx] Session context
  * @returns {Promise<string|null>} Injection text or null
  */
 export async function dispatchOnPreToolUse(db, event, sessionCtx = {}) {
-  if (!db || !event) return null;
+  if (!event) return null;
 
   try {
-    // Tier 0: Fast filter
-    const { skip } = shouldSkipDispatch(event);
-    if (skip) return null;
+    // Only process Bash tool events (error patterns come from bash)
+    if (event.tool_name !== 'Bash') return null;
 
-    // Phase transition gate: only dispatch on phase transitions to reduce noise.
-    // The first few events (≤3) always pass to allow initial recommendations.
+    // Detect failure patterns from session event history
     const allEvents = peekToolEvents();
-    const currentPhase = inferSessionPhase(allEvents);
-    const prevPhase = allEvents.length > 1 ? inferSessionPhase(allEvents.slice(0, -1)) : null;
-    const phaseChanged = isPhaseTransition(prevPhase, currentPhase);
-
-    if (!phaseChanged && allEvents.length > 3) return null;
-
-    // Tier 1: Extract context signals
-    const signals = extractContextSignals(event, sessionCtx);
-
-    // Suite protection: if a suite auto-flow is active, suppress recommendations
-    // for stages the suite already covers
-    const activeSuite = detectActiveSuite(allEvents);
-    if (activeSuite) {
-      const stage = inferCurrentStage(signals.primaryIntent, activeSuite, signals.suppressedIntents);
-      if (stage) {
-        const { shouldRecommend } = shouldRecommendForStage(activeSuite, stage);
-        if (!shouldRecommend) return null;
-      }
-    }
-    let query = buildEnhancedQuery(signals);
-    if (!query && sessionCtx?.userPrompt) {
-      query = buildQueryFromText(sessionCtx.userPrompt);
-      if (!query) return null;
-    }
-    if (!query) return null;
+    const failurePattern = detectFailurePattern(allEvents);
+    if (!failurePattern) return null;
+
+    // Extract error keywords from PREVIOUS failing events (not current — tool hasn't executed yet)
+    const failingEvents = allEvents.filter(e =>
+      e.tool_name === 'Bash' && /error|fail|exception/i.test(e.tool_response || '')
+    ).slice(-3);
+    const keywords = [...new Set(failingEvents.flatMap(e =>
+      extractErrorKeywords(e.tool_input?.command || '', e.tool_response || '') || []
+    ))];
+    if (keywords.length === 0) return null;
+
+    // Search past observations for similar errors (Option A: observations only, no registry)
+    return recallSimilarErrors(keywords, inferProject(), sessionCtx?._obsDb);
+  } catch (e) {
+    debugCatch(e, 'dispatchOnPreToolUse');
+    return null;
+  }
+}
 
-    const projectDomains = detectProjectDomains();
+// ─── Error Recall ─────────────────────────────────────────────────────────────
 
-    // Tier 2: FTS5 retrieval
-    let results = retrieveResources(db, query, { limit: 3, projectDomains });
-    results = postProcessResults(results, signals, db);
-    if (results.length === 0) return null;
+/**
+ * Search past observations for similar errors and return formatted context.
+ * @param {string[]} errorKeywords Keywords extracted from current error
+ * @param {string} project Current project name
+ * @returns {string|null} Formatted recall text or null
+ */
+export function recallSimilarErrors(errorKeywords, project, externalDb) {
+  const db = externalDb || openDb();
+  if (!db) return null;
+  const shouldClose = !externalDb;
 
-    // Apply DB-persisted cooldown and session dedup (hoisted cap + cooldown avoids N queries)
-    const sid = sessionCtx.sessionId || null;
-    if (sid && isSessionCapped(db, sid)) return null;
-    const cooldown = getAdaptiveCooldown(db);
-    const viable = sid
-      ? results.filter(r => !isRecentlyRecommended(db, r.id, sid, { skipCapCheck: true, cooldown }))
-      : results;
-    if (viable.length === 0) return null;
-    const best = viable[0];
-
-    // Record invocation (also serves as cooldown/dedup marker)
-    recordInvocation(db, {
-      resource_id: best.id,
-      session_id: sid,
-      trigger: 'pre_tool_use',
-      tier: 2,
-      recommended: 1,
-    });
-    updateResourceStats(db, best.id, 'recommend_count');
+  try {
+    const query = sanitizeFtsQuery(errorKeywords.join(' '));
+    if (!query || !query.trim()) return null;
+
+    // Search project-scoped bugfixes first
+    let rows = db.prepare(`
+      SELECT id, type, title, narrative, lesson_learned, importance, created_at
+      FROM observations
+      WHERE id IN (
+        SELECT rowid FROM observations_fts WHERE observations_fts MATCH ?
+      )
+      AND type = 'bugfix'
+      AND importance >= 2
+      AND project = ?
+      ORDER BY importance DESC, created_at DESC
+      LIMIT 3
+    `).all(query, project);
+
+    // Fallback: search across all projects
+    if (rows.length === 0) {
+      rows = db.prepare(`
+        SELECT id, type, title, narrative, lesson_learned, importance, created_at
+        FROM observations
+        WHERE id IN (
+          SELECT rowid FROM observations_fts WHERE observations_fts MATCH ?
+        )
+        AND type = 'bugfix'
+        AND importance >= 2
+        ORDER BY importance DESC, created_at DESC
+        LIMIT 3
+      `).all(query);
+    }
+
+    if (rows.length === 0) return null;
 
-    const tier = decideTier(best, signals);
-    if (tier === 'silent') return null;
-    if (tier === 'hint') return renderHint(best);
-    return renderInjection(best, buildRecommendReason(signals));
+    const lines = ['<memory-recall source="error-pattern">'];
+    lines.push('You encountered similar errors before:');
+    for (const r of rows) {
+      lines.push(`- #${r.id}: ${truncate(r.title, 80)}`);
+      if (r.lesson_learned) lines.push(`  Lesson: ${r.lesson_learned}`);
+      else if (r.narrative) lines.push(`  Context: ${truncate(r.narrative, 120)}`);
+    }
+    lines.push('Use mem_get(ids=[...]) for full details.');
+    lines.push('</memory-recall>');
+    return lines.join('\n');
   } catch (e) {
-    debugCatch(e, 'dispatchOnPreToolUse');
+    debugCatch(e, 'recallSimilarErrors');
     return null;
+  } finally {
+    if (shouldClose) db.close();
   }
 }

package/hook-episode.mjs

@@ -216,14 +216,18 @@ export function mergePendingEntries(episode) {
  * @returns {boolean} true if the episode has significant content
  */
 export function episodeHasSignificantContent(episode) {
-  // 1. File edits or Bash errors → always significant
-  const hasEditsOrErrors = episode.entries.some(e =>
-    EDIT_TOOLS.has(e.tool) ||
-    (e.tool === 'Bash' && e.isError)
+  // 1. File edits → always significant (code changes matter)
+  const hasEdits = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
+  if (hasEdits) return true;
+
+  // 2. Test/build errors → significant (actionable failures)
+  // Plain bash errors without edits are noise (e.g. typos, exploration errors)
+  const hasTestOrBuildError = episode.entries.some(e =>
+    e.tool === 'Bash' && e.isError && (e.bashSig?.isTest || e.bashSig?.isBuild)
   );
-  if (hasEditsOrErrors) return true;
+  if (hasTestOrBuildError) return true;
 
-  // 2. Important files touched (config, schema, security, migration)
+  // 3. Important files touched (config, schema, security, migration)
   // Checks episode.files (all touched files, including reads) — catches important-file investigation
   const allFiles = episode.files || [];
   const hasImportantFile = allFiles.some(f =>
@@ -232,7 +236,7 @@ export function episodeHasSignificantContent(episode) {
   );
   if (hasImportantFile) return true;
 
-  // 3. Research pattern: reading many files indicates investigation
+  // 4. Research pattern: reading many files indicates investigation
   const readCount = episode.entries.filter(e =>
     e.tool === 'Read' || e.tool === 'Grep'
   ).length;

package/hook.mjs

@@ -30,7 +30,6 @@ import {
   sessionFile, getSessionId, createSessionId, openDb, getRegistryDb,
   closeRegistryDb, spawnBackground, appendToolEvent, readAndClearToolEvents,
   resetInjectionBudget, hasInjectionBudget, incrementInjection,
-  cachePrevContext, readAndClearPrevContext,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
 import { searchRelevantMemories, recallForFile } from './hook-memory.mjs';
@@ -758,13 +757,6 @@ async function handleSessionStart() {
     updateClaudeMd([...summaryLines, ...handoffLines].join('\n'));
 
     // Cache previous session context for user-prompt dispatch enrichment.
-    // Session-start has project history but zero user intent — dispatching here
-    // produced 0/119 adoption. Instead, cache next_steps and combine with
-    // the first user-prompt for richer signal (see handleUserPrompt).
-    if (latestSummary?.next_steps) {
-      cachePrevContext(latestSummary.next_steps);
-    }
-
     // Background rescan: detect changed/new managed resources since last scan.
     // TTL-based (1h) — avoids redundant filesystem scans on every session.
     // Non-blocking: spawns detached worker, results available before first user prompt.
@@ -920,15 +912,11 @@ async function handleUserPrompt() {
     db.close();
   }
 
-  // Dispatch: recommend skill/agent based on user's actual prompt.
-  // This is the ideal dispatch point — fires when the user submits their prompt,
-  // before Claude starts working. Previous session's next_steps (cached at session-start)
-  // enriches the signal when available, combining project history with user intent.
+  // Dispatch: only fires for explicit user requests ("I need X skill", "find me a tool for Y")
   try {
     const rdb = getRegistryDb();
     if (rdb && hasInjectionBudget()) {
-      const prevContext = readAndClearPrevContext();
-      const result = await dispatchOnUserPrompt(rdb, promptText, sessionId, { prevContext });
+      const result = await dispatchOnUserPrompt(rdb, promptText, sessionId);
       if (result) {
         process.stdout.write(result + '\n');
         incrementInjection();

package/package.json

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

package/registry-retriever.mjs

@@ -349,6 +349,11 @@ export function filterByProjectDomain(results, projectDomains) {
 // Sign convention: more negative = better. BM25 is negative, behavioral signals are subtracted.
 const COMPOSITE_EXPR = `(
     bm25(resources_fts, 3.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0, 1.0) * 0.4
+    * CASE COALESCE(r.quality_tier, 'community')
+        WHEN 'installed' THEN 3.0
+        WHEN 'verified' THEN 2.0
+        ELSE 1.0
+      END
     - COALESCE(r.repo_stars * 1.0 / (r.repo_stars + 100.0), 0) * 0.15
     - (
         (COALESCE(r.success_count, 0) + 1.0) / (COALESCE(r.recommend_count, 0) + 2.0) * 0.5

package/registry.mjs

@@ -34,6 +34,10 @@ const RESOURCES_SCHEMA = `
     tech_stack    TEXT DEFAULT '',
     use_cases     TEXT DEFAULT '',
     complexity    TEXT DEFAULT 'intermediate',
+    category          TEXT,
+    quality_tier      TEXT DEFAULT 'community',
+    popularity_score  REAL DEFAULT 0,
+    personal_score    REAL DEFAULT 0,
     recommend_count   INTEGER DEFAULT 0,
     adopt_count       INTEGER DEFAULT 0,
     weighted_adopt_sum REAL DEFAULT 0,
@@ -173,6 +177,13 @@ export function ensureRegistryDb(dbPath) {
     if (!resCols.has('recommendation_mode')) db.exec("ALTER TABLE resources ADD COLUMN recommendation_mode TEXT DEFAULT 'proactive'");
     // weighted_adopt_sum: continuous adoption score accumulator (vs binary adopt_count)
     if (!resCols.has('weighted_adopt_sum')) db.exec("ALTER TABLE resources ADD COLUMN weighted_adopt_sum REAL DEFAULT 0");
+    // Phase 2: Registry optimization columns
+    if (!resCols.has('category')) db.exec("ALTER TABLE resources ADD COLUMN category TEXT");
+    if (!resCols.has('quality_tier')) db.exec("ALTER TABLE resources ADD COLUMN quality_tier TEXT DEFAULT 'community'");
+    if (!resCols.has('popularity_score')) db.exec("ALTER TABLE resources ADD COLUMN popularity_score REAL DEFAULT 0");
+    if (!resCols.has('personal_score')) db.exec("ALTER TABLE resources ADD COLUMN personal_score REAL DEFAULT 0");
+    // Auto-set quality_tier for installed preinstalled resources
+    db.exec("UPDATE resources SET quality_tier = 'installed' WHERE source = 'preinstalled' AND quality_tier = 'community'");
   } catch (e) { debugCatch(e, 'resources-column-migration'); }
 
   // FTS5 + triggers: only create if not exists

package/server.mjs

@@ -918,7 +918,7 @@ server.registerTool(
   safeHandler(async (args) => {
     if (args.project) args = { ...args, project: resolveProject(args.project) };
     const preview = args.preview !== false;
-    const ageDays = args.age_days ?? 60;
+    const ageDays = args.age_days ?? 30;
     const cutoff = Date.now() - ageDays * 86400000;
     const projectFilter = args.project ? 'AND project = ?' : '';
     const baseParams = args.project ? [args.project] : [];
@@ -1103,9 +1103,32 @@ server.registerTool(
         `  Pending purge (idle-marked): ${pendingPurge.count}`,
       ];
       if (duplicates.length > 0) {
-        lines.push('', 'Top duplicates:');
-        for (const d of duplicates.slice(0, DUPLICATE_DISPLAY)) {
-          lines.push(`  [${d.a.id}] "${truncate(d.a.title, 40)}" <-> [${d.b.id}] "${truncate(d.b.title, 40)}" (${d.similarity})`);
+        const AUTO_MERGE_THRESHOLD = 0.85;
+        const autoMergeable = duplicates.filter(d => parseFloat(d.similarity) >= AUTO_MERGE_THRESHOLD);
+        const manualReview = duplicates.filter(d => parseFloat(d.similarity) < AUTO_MERGE_THRESHOLD);
+
+        if (autoMergeable.length > 0) {
+          lines.push('', `Auto-mergeable pairs (similarity >= ${AUTO_MERGE_THRESHOLD}):`);
+          for (const d of autoMergeable.slice(0, DUPLICATE_DISPLAY)) {
+            // Keep the higher-importance or newer observation
+            const keep = d.a.importance >= d.b.importance ? d.a : d.b;
+            const remove = keep === d.a ? d.b : d.a;
+            lines.push(`  [${keep.id}] "${truncate(keep.title, 40)}" <-> [${remove.id}] "${truncate(remove.title, 40)}" (${d.similarity})`);
+          }
+          // Build ready-to-use merge_ids for auto-mergeable pairs
+          const mergeIds = autoMergeable.map(d => {
+            const keep = d.a.importance >= d.b.importance ? d.a : d.b;
+            const remove = keep === d.a ? d.b : d.a;
+            return [keep.id, remove.id];
+          });
+          lines.push('', `Ready-to-use command:`, `  mem_maintain(action="execute", operations=["dedup"], merge_ids=${JSON.stringify(mergeIds)})`);
+        }
+
+        if (manualReview.length > 0) {
+          lines.push('', 'Needs review:');
+          for (const d of manualReview.slice(0, DUPLICATE_DISPLAY)) {
+            lines.push(`  [${d.a.id}] "${truncate(d.a.title, 40)}" <-> [${d.b.id}] "${truncate(d.b.title, 40)}" (${d.similarity})`);
+          }
         }
       }
       return { content: [{ type: 'text', text: lines.join('\n') }] };
@@ -1146,7 +1169,21 @@ server.registerTool(
               LIMIT ${OP_ROW_CAP}
             )
           `).run(staleAge, ...baseParams);
-          results.push(`Decayed ${decayed.changes} stale observations` + (decayed.changes >= OP_ROW_CAP ? ' (cap reached, re-run for more)' : ''));
+
+          // Mark importance=1, never-accessed, old observations as pending-purge
+          const idleMarked = db.prepare(`
+            UPDATE observations SET compressed_into = ${COMPRESSED_PENDING_PURGE}
+            WHERE id IN (
+              SELECT id FROM observations
+              WHERE COALESCE(compressed_into, 0) = 0
+                AND COALESCE(importance, 1) = 1
+                AND COALESCE(access_count, 0) = 0
+                AND created_at_epoch < ?
+                ${projectFilter}
+              LIMIT ${OP_ROW_CAP}
+            )
+          `).run(staleAge, ...baseParams);
+          results.push(`Decayed ${decayed.changes} stale observations, marked ${idleMarked.changes} idle as pending-purge` + ((decayed.changes >= OP_ROW_CAP || idleMarked.changes >= OP_ROW_CAP) ? ' (cap reached, re-run for more)' : ''));
         }
 
         if (ops.includes('boost')) {
@@ -1224,18 +1261,24 @@ server.registerTool(
       if (!args.query) {
         return { content: [{ type: 'text', text: 'search requires a query parameter' }], isError: true };
       }
-      const results = searchResources(rdb, args.query, {
+      let results = searchResources(rdb, args.query, {
         type: args.type || undefined,
-        limit: 5,
+        limit: args.category || args.quality ? 20 : 5, // fetch more when filtering
       });
+      // Apply category/quality filters if provided
+      if (args.category) results = results.filter(r => r.category === args.category);
+      if (args.quality) results = results.filter(r => r.quality_tier === args.quality);
+      results = results.slice(0, 5);
       if (results.length === 0) {
         return { content: [{ type: 'text', text: `No matching resources for: "${args.query}"` }] };
       }
       const lines = results.map(r => {
+        const qualityBadge = r.quality_tier === 'installed' ? '[✓]' : r.quality_tier === 'verified' ? '[★]' : '[○]';
+        const categoryLabel = r.category ? ` [${r.category}]` : '';
         const howToUse = r.type === 'skill'
           ? (r.invocation_name ? `Skill tool: skill="${r.invocation_name}"` : `Community skill: ${r.name}`)
           : `Agent tool: subagent_type="${r.name}"`;
-        return `${r.type === 'skill' ? 'S' : 'A'} **${r.name}** — ${truncate(r.capability_summary || '', 80)}\n  Use: ${howToUse}`;
+        return `${qualityBadge} ${r.type === 'skill' ? 'S' : 'A'} **${r.name}**${categoryLabel} — ${truncate(r.capability_summary || '', 80)}\n  Use: ${howToUse}`;
       });
       return { content: [{ type: 'text', text: `Found ${results.length} resource(s) for "${args.query}":\n\n${lines.join('\n\n')}` }] };
     }

package/tool-schemas.mjs

@@ -74,7 +74,7 @@ export const memStatsSchema = {
 
 export const memCompressSchema = {
   preview: coerceBool.optional().describe('true=count candidates, false=execute compression (default: true)'),
-  age_days: coerceInt.pipe(z.number().int().min(30).max(365)).optional().describe('Min age in days (default: 60)'),
+  age_days: coerceInt.pipe(z.number().int().min(30).max(365)).optional().describe('Min age in days (default: 30)'),
   project: z.string().optional().describe('Filter by project'),
 };
 
@@ -108,4 +108,6 @@ export const memRegistrySchema = {
   keywords: z.string().optional().describe('Search keywords (for import)'),
   tech_stack: z.string().optional().describe('Technology stack tags (for import)'),
   use_cases: z.string().optional().describe('Usage scenarios (for import)'),
+  category: z.string().optional().describe("Filter by category (e.g., 'testing', 'code-quality', 'debugging')"),
+  quality: z.enum(['installed', 'verified', 'community']).optional().describe('Filter by quality tier (default: all)'),
 };

package/utils.mjs

@@ -561,9 +561,15 @@ export function inferProject() {
  */
 export function detectBashSignificance(input, response) {
   const cmd = (input.command || '').toLowerCase();
-  const isError = /\berror\b|\bERR!|fail(ed|ure)?|exception|panic|traceback|errno|enoent|command not found/i.test(response)
+  // Skip error keyword matching when the command is a read/search operation
+  // (grep output naturally contains matched keywords like "error")
+  const isSearchCmd = /\b(grep|rg|ag|ack|cat|head|tail|less|more|find|locate|wc|file|which|type)\b/i.test(cmd);
+  const isError = !isSearchCmd
+    && /\berror\b|\bERR!|fail(ed|ure)?|exception|panic|traceback|errno|enoent|command not found/i.test(response)
     && response.length > 15;
-  const isTest = /\b(test|jest|pytest|vitest|mocha|spec|cypress|playwright)\b/i.test(cmd);
+  // Match actual test runner invocations, not commands that merely reference "test" as a keyword
+  const isTest = /\b(npm\s+test|npm\s+run\s+test|yarn\s+test|pnpm\s+test|pnpm\s+run\s+test|bun\s+test|go\s+test|cargo\s+test)\b/i.test(cmd)
+    || /\b(jest|pytest|vitest|mocha|cypress|playwright)\b/i.test(cmd);
   const isBuild = /\b(build|compile|tsc|webpack|vite|rollup|esbuild|make|cargo)\b/i.test(cmd);
   const isGit = /\bgit\s+(commit|merge|rebase|cherry-pick|push)\b/i.test(cmd);
   const isDeploy = /\b(deploy|docker|kubectl|terraform)\b/i.test(cmd);