@cachly-dev/mcp-server 0.5.24 → 0.5.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cachly-dev/mcp-server",
-  "version": "0.5.24",
+  "version": "0.5.25",
   "mcpName": "io.github.cachly-dev/mcp-server",
   "description": "AI memory brain for Claude Code, Cursor, Copilot & Windsurf — persistent sessions, lessons learned, semantic search, team brain. 38 MCP tools.",
   "type": "module",

package/src/index.ts

@@ -2,6 +2,8 @@
 import { randomUUID } from 'node:crypto';
 import { createHash } from 'node:crypto';
 import { readdir, readFile, stat } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { join, relative, extname } from 'node:path';
 /**
  * cachly MCP Server v0.4.0
@@ -52,7 +54,7 @@ import { Redis } from 'ioredis';
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 const JWT = process.env.CACHLY_JWT ?? '';
 const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.5.24';
+const CURRENT_VERSION = '0.5.25';
 /**
  * ┌──────────────────────────────────────────────────────────────────────┐
  * │  EMBEDDING PROVIDER — pluggable, client-side first                  │
@@ -1349,6 +1351,10 @@ const TOOLS = [
           items: { type: 'string' },
           description: 'Prerequisites this lesson depends on (e.g. ["node:>=20", "docker:running", "wireguard:active"]). When a dependency is marked stale, all dependent lessons get needs_review.',
         },
+        author: {
+          type: 'string',
+          description: 'Name or handle of the person storing this lesson (e.g. "alice", "bob"). Used for Team Telepathy — teammates see each other\'s lessons in session_start.',
+        },
       },
       required: ['instance_id', 'topic', 'outcome', 'what_worked'],
     },
@@ -1393,7 +1399,8 @@ const TOOLS = [
     description:
       'Single-call session briefing. Call this at the START of every session INSTEAD of multiple separate smart_recall/recall_best_solution calls. ' +
       'Returns: last session summary, recent lessons sorted by recency, relevant lessons for your focus area, ' +
-      'open failures (topics with only failure outcomes), and brain health stats (lesson count, context count). ' +
+      'open failures (topics with only failure outcomes), brain health stats, team telepathy (what teammates learned this week), ' +
+      'predictive pre-warnings (if your focus area has known failure patterns), and memory crystals (compressed wisdom from old sessions). ' +
       'Also saves a session start marker so session_end can compute duration.',
     inputSchema: {
       type: 'object',
@@ -1403,6 +1410,10 @@ const TOOLS = [
           type: 'string',
           description: 'Keywords for what you plan to work on today (e.g. "deploy infra api"). Used to surface relevant lessons at the top.',
         },
+        author: {
+          type: 'string',
+          description: 'Your name or handle (e.g. "alice"). Enables Team Telepathy — filters YOUR lessons vs TEAM lessons from past 7 days.',
+        },
       },
       required: ['instance_id'],
     },
@@ -1413,7 +1424,8 @@ const TOOLS = [
       'Save a session summary when you finish working. ' +
       'Records what was accomplished, files changed, and lesson count. ' +
       'The next session_start will show this summary as "Last session". ' +
-      'Call this when ending a work session, before going idle, or before summarizing.',
+      'Call this when ending a work session, before going idle, or before summarizing. ' +
+      'Ambient Learning: if workspace_path is provided, reads git log since session start and auto-learns from commits.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -1431,6 +1443,10 @@ const TOOLS = [
           type: 'number',
           description: 'Number of new lessons stored this session (optional)',
         },
+        workspace_path: {
+          type: 'string',
+          description: 'Absolute path to the project root (e.g. "/Users/you/myproject"). Enables Ambient Learning — reads git log since session start and auto-learns from commit messages.',
+        },
       },
       required: ['instance_id', 'summary'],
     },
@@ -1594,16 +1610,40 @@ const TOOLS = [
       required: ['instance_id', 'topic'],
     },
   },
+  {
+    name: 'memory_crystalize',
+    description:
+      'Compress the last 30-50 sessions and auto-learned lessons into a dense Memory Crystal. ' +
+      'A crystal is a compact, structured summary of everything the brain learned — grouped by category (deploy, fix, debug, …). ' +
+      'Crystals survive session cleanup and appear in session_start once enough sessions have accumulated. ' +
+      'Run this monthly or after a big milestone to preserve institutional knowledge. ' +
+      'Returns a digest of what was crystallized.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        instance_id: { type: 'string', description: 'UUID of the cache instance' },
+        label: {
+          type: 'string',
+          description: 'Optional label for this crystal (e.g. "Q1 2026", "v2 launch"). Auto-generated from date if omitted.',
+        },
+      },
+      required: ['instance_id'],
+    },
+  },
   {
     name: 'brain_doctor',
     description:
       'Check the health of your AI Brain and get actionable recommendations. ' +
-      'Reports: lesson count, context entries, last session age, open failures, quality score. ' +
+      'Reports: lesson count, context entries, last session age, open failures, quality score, effective IQ boost, stale index. ' +
       'Returns a prioritized list of issues with fix instructions.',
     inputSchema: {
       type: 'object',
       properties: {
         instance_id: { type: 'string', description: 'UUID of the cache instance' },
+        workspace_path: {
+          type: 'string',
+          description: 'Absolute path to workspace root — enables package.json analysis for openclaw cross-promo (optional)',
+        },
       },
       required: ['instance_id'],
     },
@@ -2781,6 +2821,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         commands = [],
         tags = [],
         depends_on = [],
+        author = '',
       } = args as {
         instance_id: string;
         topic: string;
@@ -2793,6 +2834,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         commands?: string[];
         tags?: string[];
         depends_on?: string[];
+        author?: string;
       };
 
       const redis = await getConnection(instance_id);
@@ -2902,6 +2944,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         commands,
         tags,
         depends_on,
+        ...(author ? { author } : {}),
         recall_count: recallCount,
         ts,
         verified_at: outcome === 'success' || outcome === 'partial' ? ts : undefined,
@@ -3226,7 +3269,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
 
     // ── session_start ─────────────────────────────────────────────────────────
     case 'session_start': {
-      const { instance_id, focus = '' } = args as { instance_id: string; focus?: string };
+      const { instance_id, focus = '', author = '' } = args as { instance_id: string; focus?: string; author?: string };
       const redis = await getConnection(instance_id);
 
       // 1. Scan all best-solution lessons
@@ -3437,6 +3480,74 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         lines.push('');
       }
 
+      // ── 🔮 Predictive Pre-Warning — intent-based danger detection ────────────
+      // Fires BEFORE work starts. If focus area has known failure patterns → warn loudly.
+      if (focusTerms.length > 0) {
+        type LessonWithAuthor = typeof lessons[0] & { author?: string };
+        const dangerLessons = (lessons as LessonWithAuthor[]).filter(l => {
+          if (l.outcome === 'success') return false;
+          const topicCategory = l.topic.split(':')[0];
+          return focusTerms.some(term =>
+            l.topic.toLowerCase().includes(term) ||
+            topicCategory === term ||
+            (l.tags ?? []).some((t: string) => t.toLowerCase() === term),
+          );
+        });
+        if (dangerLessons.length >= 1) {
+          lines.unshift(''); // push to top after title
+          lines.unshift(`  ❌ ${dangerLessons.slice(0, 3).map(l => `\`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`).join('\n  ❌ ')}`);
+          lines.unshift(`  Known pitfalls for **"${focus}"** (${dangerLessons.length} past failure${dangerLessons.length > 1 ? 's' : ''}):`); 
+          lines.unshift(`🚨 **PRE-WARNING** — Read this BEFORE starting:`);
+        }
+      }
+
+      // ── 👥 Team Telepathy — what teammates learned this week ─────────────────
+      if (author) {
+        type LessonWithAuthor = typeof lessons[0] & { author?: string };
+        const oneWeekAgo = Date.now() - 7 * 86_400_000;
+        const teamLessons = (lessons as LessonWithAuthor[]).filter(l =>
+          l.author && l.author !== author && new Date(l.ts).getTime() > oneWeekAgo,
+        );
+        if (teamLessons.length > 0) {
+          // Group by author
+          const byAuthor = new Map<string, LessonWithAuthor[]>();
+          for (const l of teamLessons) {
+            const a = l.author!;
+            if (!byAuthor.has(a)) byAuthor.set(a, []);
+            byAuthor.get(a)!.push(l);
+          }
+          lines.push(`👥 **Team this week** (${teamLessons.length} lesson${teamLessons.length > 1 ? 's' : ''} from teammates):`);
+          for (const [teamAuthor, tls] of byAuthor) {
+            lines.push(`  👤 **${teamAuthor}**:`);
+            for (const l of tls.slice(0, 3)) {
+              const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
+              lines.push(`    ${emoji} \`${l.topic}\` — ${l.what_worked.slice(0, 80)}`);
+            }
+            if (tls.length > 3) lines.push(`    … and ${tls.length - 3} more`);
+          }
+          lines.push('');
+        }
+      }
+
+      // ── 💎 Memory Crystal — compressed wisdom from old sessions ──────────────
+      try {
+        const crystalRaw = await redis.get('cachly:crystal:latest');
+        if (crystalRaw) {
+          const crystal = JSON.parse(crystalRaw) as {
+            label: string; ts: string; session_count: number;
+            top_patterns: Array<{ category: string; insight: string; count: number }>;
+          };
+          const crystalAge = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
+          if (crystalAge <= 90) {
+            lines.push(`💎 **Memory Crystal** (${crystal.label} · ${crystal.session_count} sessions compressed):`);
+            for (const p of crystal.top_patterns.slice(0, 3)) {
+              lines.push(`  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 90)}`);
+            }
+            lines.push('');
+          }
+        }
+      } catch { /* non-critical */ }
+
       return lines.join('\n');
     }
 
@@ -3447,11 +3558,13 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         summary,
         files_changed = [],
         lessons_learned,
+        workspace_path = '',
       } = args as {
         instance_id: string;
         summary: string;
         files_changed?: string[];
         lessons_learned?: number;
+        workspace_path?: string;
       };
 
       const redis = await getConnection(instance_id);
@@ -3569,6 +3682,53 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         }
       } catch { /* auto-learn errors must never break session_end */ }
 
+      // ── 🌿 Ambient Git Learning ────────────────────────────────────────────────
+      // Read git commits since session start → auto-learn each meaningful commit.
+      const ambientLearned: string[] = [];
+      if (workspace_path) {
+        try {
+          // Get the session start time (stored by session_start)
+          const sessionStartTs = currentRaw
+            ? (() => { try { return (JSON.parse(currentRaw) as { started?: string }).started ?? ''; } catch { return ''; } })()
+            : '';
+          const sinceArg = sessionStartTs ? `--since="${sessionStartTs}"` : '--since="1 hour ago"';
+          const gitOut = execSync(
+            `git -C "${workspace_path}" log ${sinceArg} --oneline --format="%H|||%s|||%ai"`,
+            { timeout: 5000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+          ).trim();
+          if (gitOut) {
+            const commitActionRe = /\b(fix|add|remove|refactor|migrate|update|resolve|implement|improve|optimize|configure|create|delete|disable|enable|debug|patch|upgrade|build|rewrite|deploy|feat|chore|docs|test|perf|ci)\b/i;
+            for (const line of gitOut.split('\n').slice(0, 10)) {
+              const [hash, msg, dateStr] = line.split('|||');
+              if (!msg || !commitActionRe.test(msg)) continue;
+              const slug = msg
+                .toLowerCase().replace(/^(fix|feat|chore|docs|test|ci|perf|refactor|build|revert)[:(\s]/i, '')
+                .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
+              if (!slug) continue;
+              const topic = `git:${slug}`;
+              const key = `cachly:lesson:best:${topic}`;
+              const existing = await redis.get(key);
+              if (existing) continue; // don't overwrite existing
+              const commitLesson = {
+                topic,
+                outcome: 'success' as const,
+                what_worked: msg.slice(0, 200),
+                context: `Auto-learned from git commit ${(hash ?? '').slice(0, 7)} at ${dateStr ?? ''} in ${workspace_path}`,
+                severity: 'minor' as const,
+                ts: now.toISOString(),
+                recall_count: 0,
+                auto_learned: true,
+                source: 'ambient-git',
+                version: 3,
+              };
+              await redis.set(key, JSON.stringify(commitLesson));
+              await redis.expire(key, 60 * 86400); // 60 day TTL for git lessons
+              ambientLearned.push(topic);
+            }
+          }
+        } catch { /* git not available or not a repo — silent skip */ }
+      }
+
       const durationStr = durationMin !== undefined ? ` · ${durationMin} min` : '';
       return [
         `✅ **Session saved**${durationStr}`,
@@ -3577,6 +3737,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         files_changed.length > 0 ? `📁 **Files changed:** ${files_changed.map(f => `\`${f}\``).join(', ')}` : '',
         lessons_learned !== undefined ? `🧠 **Lessons stored:** ${lessons_learned}` : '',
         autoLearned.length > 0 ? `🤖 **Auto-learned:** ${autoLearned.length} lessons extracted from summary (${autoLearned.slice(0, 3).map(t => `\`${t}\``).join(', ')}${autoLearned.length > 3 ? '…' : ''})` : '',
+        ambientLearned.length > 0 ? `🌿 **Ambient git learning:** ${ambientLearned.length} commit${ambientLearned.length > 1 ? 's' : ''} auto-learned (${ambientLearned.slice(0, 3).map(t => `\`${t}\``).join(', ')}${ambientLearned.length > 3 ? '…' : ''})` : '',
         ``,
         `💡 Next session: \`session_start(focus="...")\` to see this summary.`,
       ].filter(l => l !== '').join('\n');
@@ -3932,8 +4093,87 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
     }
 
     // ── brain_doctor ──────────────────────────────────────────────────────────
+    // ── memory_crystalize ─────────────────────────────────────────────────────
+    case 'memory_crystalize': {
+      const { instance_id, label: crystalLabel = '' } = args as { instance_id: string; label?: string };
+      const redis = await getConnection(instance_id);
+      const now = new Date();
+      const week = `${now.getFullYear()}-W${String(Math.ceil((now.getDate() - now.getDay() + 10) / 7)).padStart(2, '0')}`;
+      const effectiveLabel = crystalLabel || `${now.toISOString().slice(0, 7)} Crystal`;
+
+      // Read session history
+      const sessionHistory = await redis.lrange('cachly:session:history', 0, 49);
+
+      // Read all auto-learned lessons
+      const allLessonKeys: string[] = [];
+      const ls = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
+      await new Promise<void>((res, rej) => {
+        ls.on('data', (b: string[]) => allLessonKeys.push(...b));
+        ls.on('end', res);
+        ls.on('error', rej);
+      });
+
+      type RawLesson = { topic: string; outcome: string; what_worked: string; severity?: string; ts: string; auto_learned?: boolean };
+      const allLessons: RawLesson[] = [];
+      for (const k of allLessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { allLessons.push(JSON.parse(raw) as RawLesson); } catch { /* skip */ }
+      }
+
+      // Group lessons by top-level category
+      const categoryMap = new Map<string, RawLesson[]>();
+      for (const l of allLessons) {
+        const cat = l.topic.split(':')[0] || 'misc';
+        if (!categoryMap.has(cat)) categoryMap.set(cat, []);
+        categoryMap.get(cat)!.push(l);
+      }
+
+      // Build top patterns (most frequent categories with a representative insight)
+      const topPatterns: Array<{ category: string; insight: string; count: number }> = [];
+      for (const [cat, catLessons] of [...categoryMap.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 8)) {
+        const successLessons = catLessons.filter(l => l.outcome === 'success');
+        const best = successLessons[0] ?? catLessons[0];
+        if (!best) continue;
+        topPatterns.push({
+          category: cat,
+          insight: best.what_worked.slice(0, 120),
+          count: catLessons.length,
+        });
+      }
+
+      const crystal = {
+        label: effectiveLabel,
+        ts: now.toISOString(),
+        session_count: sessionHistory.length,
+        lesson_count: allLessons.length,
+        top_patterns: topPatterns,
+        categories: [...categoryMap.keys()],
+        created_from: `${sessionHistory.length} sessions, ${allLessons.length} lessons`,
+      };
+
+      const crystalJson = JSON.stringify(crystal);
+      await redis.set('cachly:crystal:latest', crystalJson);
+      await redis.expire('cachly:crystal:latest', 90 * 86400);
+      await redis.set(`cachly:crystal:${week}`, crystalJson);
+      await redis.expire(`cachly:crystal:${week}`, 365 * 86400);
+
+      const lines = [
+        `💎 **Memory Crystal created: ${effectiveLabel}**`,
+        ``,
+        `📊 Compressed: **${sessionHistory.length} sessions** + **${allLessons.length} lessons** → ${topPatterns.length} top patterns`,
+        ``,
+        `**Top patterns by category:**`,
+        ...topPatterns.slice(0, 6).map(p => `  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 90)}`),
+        ``,
+        `💡 This crystal will appear in every future \`session_start\` briefing.`,
+        `💡 Re-run \`memory_crystalize\` monthly to keep it fresh.`,
+      ];
+      return lines.join('\n');
+    }
+
     case 'brain_doctor': {
-      const { instance_id } = args as { instance_id: string };
+      const { instance_id, workspace_path: drWorkspacePath = '' } = args as { instance_id: string; workspace_path?: string };
       const redis = await getConnection(instance_id);
       const issues: string[] = [];
       const checks: string[] = [];
@@ -3987,6 +4227,13 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       const staleLessons  = lessons.filter(l => l.outcome === 'success' && calculateConfidence(l) < CONFIDENCE_STALE_VALUE);
       const warnLessons   = lessons.filter(l => l.outcome === 'success' && calculateConfidence(l) >= CONFIDENCE_STALE_VALUE && calculateConfidence(l) < CONFIDENCE_WARN_VALUE);
       const withAudit     = lessons.filter(l => (l.audit_trail ?? []).length > 1);
+      // Team lessons
+      type DrLessonWithAuthor = DrLesson & { author?: string };
+      const teamLessons = (lessons as DrLessonWithAuthor[]).filter(l => l.author);
+      const uniqueAuthors = new Set((lessons as DrLessonWithAuthor[]).map(l => l.author).filter(Boolean));
+      // Effective IQ boost: total recalls / lessons (how much the brain actually helped)
+      const totalRecalls = lessons.reduce((sum, l) => sum + (l.recall_count ?? 0), 0);
+      const iqBoostPct = lessons.length > 0 ? Math.min(100, Math.round((totalRecalls / lessons.length) * 10)) : 0;
 
       // Quality score (0-100)
       let score = 50;
@@ -3999,14 +4246,66 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       const unusedRatio = lessons.length > 0 ? unusedLessons.length / lessons.length : 0;
       if (unusedRatio < 0.5)       score += 10;
       if (staleLessons.length === 0) score += 5;
+      if (uniqueAuthors.size >= 2) score += 5; // team collaboration bonus
 
       const scoreEmoji = score >= 80 ? '🟢' : score >= 50 ? '🟡' : '🔴';
+      const iqEmoji = iqBoostPct >= 50 ? '🚀' : iqBoostPct >= 20 ? '📈' : '💤';
 
       checks.push(`${scoreEmoji} **Brain Quality Score: ${score}/100**`);
-      checks.push(`📚 **Lessons:** ${lessonKeys.length} (${criticalLessons.length} critical · ${withAudit.length} with audit trail)`);
+      checks.push(`${iqEmoji} **Effective IQ Boost: ${iqBoostPct}%** (${totalRecalls} recalls across ${lessons.length} lessons)`);
+      checks.push(`📚 **Lessons:** ${lessonKeys.length} (${criticalLessons.length} critical · ${withAudit.length} with audit trail · ${teamLessons.length} from team)`);
       checks.push(`💾 **Context entries:** ${ctxCount}`);
       checks.push(`🎯 **Confidence:** ${lessons.length - staleLessons.length - warnLessons.length} fresh · ${warnLessons.length} warn · ${staleLessons.length} stale`);
       checks.push(`⏱️ **Decay config:** warn after ${CONFIDENCE_WARN_DAYS}d · stale after ${CONFIDENCE_STALE_DAYS}d`);
+      if (uniqueAuthors.size >= 2) {
+        checks.push(`👥 **Team:** ${uniqueAuthors.size} contributors (${[...uniqueAuthors].join(', ')})`);
+      }
+
+      // Stale index detection
+      try {
+        const lastIndexRaw = await redis.get('cachly:index:last_run');
+        if (lastIndexRaw) {
+          const lastIndexAge = Math.round((Date.now() - new Date(lastIndexRaw).getTime()) / 86_400_000);
+          if (lastIndexAge > 7) {
+            issues.push(`🔄 Index is ${lastIndexAge}d stale — run \`index_project\` to re-sync semantic search`);
+          } else {
+            checks.push(`🗂️ **Semantic index:** ${lastIndexAge}d old (fresh)`);
+          }
+        } else {
+          issues.push(`💡 No semantic index — run \`index_project(dir="<your-src>")\` to enable semantic search`);
+        }
+      } catch { /* non-critical */ }
+
+      // Memory crystal status
+      try {
+        const crystalRaw = await redis.get('cachly:crystal:latest');
+        if (crystalRaw) {
+          const crystal = JSON.parse(crystalRaw) as { ts: string; label: string };
+          const crystalAge = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
+          checks.push(`💎 **Memory Crystal:** ${crystal.label} (${crystalAge}d ago)`);
+          if (crystalAge > 30) issues.push(`💡 Memory Crystal is ${crystalAge}d old — re-run \`memory_crystalize\` to compress new sessions`);
+        } else if (lessonKeys.length >= 10) {
+          issues.push(`💡 ${lessonKeys.length} lessons but no Memory Crystal — run \`memory_crystalize\` to compress wisdom`);
+        }
+      } catch { /* non-critical */ }
+
+      // openclaw cross-promo (check package.json in workspace)
+      if (drWorkspacePath) {
+        try {
+          const pkgPath = drWorkspacePath.replace(/\/$/, '') + '/package.json';
+          const pkgRaw = readFileSync(pkgPath, 'utf-8');
+          const pkg = JSON.parse(pkgRaw) as { dependencies?: Record<string, string>; devDependencies?: Record<string, string> };
+          const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+          const hasLLMDep = ['openai', '@anthropic-ai/sdk', '@google/generative-ai', 'mistralai', 'cohere-ai'].some(d => d in allDeps);
+          const hasOpenclaw = '@cachly-dev/openclaw' in allDeps;
+          if (hasLLMDep && !hasOpenclaw) {
+            issues.push(`💡 **openclaw missing:** you use LLM APIs (${Object.keys(allDeps).filter(d => ['openai','@anthropic-ai/sdk'].includes(d)).join(', ')}) but not \`@cachly-dev/openclaw\``);
+            issues.push(`   → \`npm install @cachly-dev/openclaw\` cuts LLM costs 60–90% with 3 lines of code`);
+          } else if (hasOpenclaw) {
+            checks.push(`✅ **@cachly-dev/openclaw installed** (LLM cost caching active)`);
+          }
+        } catch { /* no package.json or unreadable */ }
+      }
 
       if (lastSession) {
         const ageMin = Math.round((Date.now() - new Date(lastSession.ts).getTime()) / 60000);
@@ -4022,6 +4321,10 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         issues.push(`💡 Only ${lessonKeys.length} lessons — add more after each problem solved`);
       }
 
+      if (iqBoostPct === 0 && lessons.length >= 5) {
+        issues.push(`💤 **IQ Boost is 0%** — lessons exist but are never recalled. Use \`recall_best_solution\` BEFORE tasks.`);
+      }
+
       if (ctxCount === 0) {
         issues.push('💡 No context — use `remember_context` to cache architecture docs, ADRs, etc.');
       }