@cachly-dev/mcp-server 0.5.23 → 0.5.25

package/dist/index.js

@@ -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
@@ -44,7 +46,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.23';
+const CURRENT_VERSION = '0.5.25';
 /**
  * ┌──────────────────────────────────────────────────────────────────────┐
  * │  EMBEDDING PROVIDER — pluggable, client-side first                  │
@@ -1214,6 +1216,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'],
         },
@@ -1255,7 +1261,8 @@ const TOOLS = [
         name: 'session_start',
         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',
@@ -1265,6 +1272,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'],
         },
@@ -1274,7 +1285,8 @@ const TOOLS = [
         description: '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: {
@@ -1292,6 +1304,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'],
         },
@@ -1449,15 +1465,38 @@ 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'],
         },
@@ -2465,7 +2504,7 @@ async function handleTool(name, args) {
             return `🗑️ **Forgot ${deleted} context entries.**\n\nKeys: ${keys.map(k => `\`${k}\``).join(', ')}`;
         }
         case 'learn_from_attempts': {
-            const { instance_id, topic, outcome, what_worked, what_failed = '', context: ctx = '', severity = 'major', file_paths = [], commands = [], tags = [], depends_on = [], } = args;
+            const { instance_id, topic, outcome, what_worked, what_failed = '', context: ctx = '', severity = 'major', file_paths = [], commands = [], tags = [], depends_on = [], author = '', } = args;
             const redis = await getConnection(instance_id);
             const ts = new Date().toISOString();
             // ── Structured template hints ──────────────────────────────────────────
@@ -2561,6 +2600,7 @@ async function handleTool(name, args) {
                 commands,
                 tags,
                 depends_on,
+                ...(author ? { author } : {}),
                 recall_count: recallCount,
                 ts,
                 verified_at: outcome === 'success' || outcome === 'partial' ? ts : undefined,
@@ -2844,7 +2884,7 @@ async function handleTool(name, args) {
         }
         // ── session_start ─────────────────────────────────────────────────────────
         case 'session_start': {
-            const { instance_id, focus = '' } = args;
+            const { instance_id, focus = '', author = '' } = args;
             const redis = await getConnection(instance_id);
             // 1. Scan all best-solution lessons
             const lessonKeys = [];
@@ -3047,11 +3087,71 @@ async function handleTool(name, args) {
                     lines.push(`  ❌ Failed: ${failures.slice(0, 3).map(d => `\`${d.topic}\``).join(', ')}`);
                 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) {
+                const dangerLessons = lessons.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) => 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) {
+                const oneWeekAgo = Date.now() - 7 * 86_400_000;
+                const teamLessons = lessons.filter(l => l.author && l.author !== author && new Date(l.ts).getTime() > oneWeekAgo);
+                if (teamLessons.length > 0) {
+                    // Group by author
+                    const byAuthor = new Map();
+                    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);
+                    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');
         }
         // ── session_end ───────────────────────────────────────────────────────────
         case 'session_end': {
-            const { instance_id, summary, files_changed = [], lessons_learned, } = args;
+            const { instance_id, summary, files_changed = [], lessons_learned, workspace_path = '', } = args;
             const redis = await getConnection(instance_id);
             const now = new Date();
             // Calculate duration from session_start marker
@@ -3161,6 +3261,58 @@ async function handleTool(name, args) {
                 }
             }
             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 = [];
+            if (workspace_path) {
+                try {
+                    // Get the session start time (stored by session_start)
+                    const sessionStartTs = currentRaw
+                        ? (() => { try {
+                            return JSON.parse(currentRaw).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',
+                                what_worked: msg.slice(0, 200),
+                                context: `Auto-learned from git commit ${(hash ?? '').slice(0, 7)} at ${dateStr ?? ''} in ${workspace_path}`,
+                                severity: 'minor',
+                                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}`,
@@ -3169,6 +3321,7 @@ async function handleTool(name, args) {
                 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');
@@ -3455,8 +3608,83 @@ async function handleTool(name, args) {
             return lines;
         }
         // ── brain_doctor ──────────────────────────────────────────────────────────
+        // ── memory_crystalize ─────────────────────────────────────────────────────
+        case 'memory_crystalize': {
+            const { instance_id, label: crystalLabel = '' } = args;
+            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 = [];
+            const ls = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
+            await new Promise((res, rej) => {
+                ls.on('data', (b) => allLessonKeys.push(...b));
+                ls.on('end', res);
+                ls.on('error', rej);
+            });
+            const allLessons = [];
+            for (const k of allLessonKeys) {
+                const raw = await redis.get(k);
+                if (!raw)
+                    continue;
+                try {
+                    allLessons.push(JSON.parse(raw));
+                }
+                catch { /* skip */ }
+            }
+            // Group lessons by top-level category
+            const categoryMap = new Map();
+            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 = [];
+            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;
+            const { instance_id, workspace_path: drWorkspacePath = '' } = args;
             const redis = await getConnection(instance_id);
             const issues = [];
             const checks = [];
@@ -3507,6 +3735,11 @@ async function handleTool(name, args) {
             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);
+            const teamLessons = lessons.filter(l => l.author);
+            const uniqueAuthors = new Set(lessons.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;
             if (lessonKeys.length >= 5)
@@ -3526,12 +3759,70 @@ async function handleTool(name, args) {
                 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);
+                    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);
+                    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);
                 const ageStr = ageMin < 60 ? `${ageMin}m` : ageMin < 1440 ? `${Math.round(ageMin / 60)}h` : `${Math.round(ageMin / 1440)}d`;
@@ -3546,6 +3837,9 @@ async function handleTool(name, args) {
             else if (lessonKeys.length < 5) {
                 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.');
             }