@cachly-dev/mcp-server 0.9.1 → 0.9.2

package/dist/index.js

@@ -47,7 +47,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.8.3';
+const CURRENT_VERSION = '0.9.2';
 /**
  * ┌──────────────────────────────────────────────────────────────────────┐
  * │  EMBEDDING PROVIDER — pluggable, client-side first                  │
@@ -2171,6 +2171,45 @@ async function apiFetch(path, options = {}) {
     return res.json();
 }
 import { detectNamespace } from './namespace.js';
+const STOPWORDS_CKG = new Set(['that', 'this', 'with', 'from', 'when', 'then', 'also', 'have', 'been', 'will', 'were', 'they', 'them', 'than', 'more', 'some', 'into', 'over', 'only', 'just', 'where', 'while', 'which', 'there', 'their', 'would', 'could', 'should', 'after', 'before', 'about']);
+function ckgSlug(text) {
+    return text.toLowerCase().replace(/[^a-z0-9\-:]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 80);
+}
+/** Extract 1-3 significant keywords from free text for a problem concept */
+function extractProblemConcept(text) {
+    const words = text.toLowerCase()
+        .replace(/[^a-z0-9\s\-_]/g, ' ').split(/\s+/)
+        .filter(w => w.length > 3 && !STOPWORDS_CKG.has(w))
+        .slice(0, 5);
+    if (words.length === 0)
+        return null;
+    return words.slice(0, 2).join('-');
+}
+async function ckgUpsertNode(redis, id, domain, type) {
+    const key = `cachly:ckg:node:${id}`;
+    const raw = await redis.get(key);
+    const node = raw ? JSON.parse(raw) : { id, domain, type, count: 0, ts: new Date().toISOString() };
+    node.count = (node.count || 0) + 1;
+    node.ts = new Date().toISOString();
+    await redis.set(key, JSON.stringify(node));
+}
+async function ckgUpdateEdge(redis, from, edgeType, to, success, partial = false) {
+    const key = `cachly:ckg:edge:${from}:${edgeType}:${to}`;
+    const raw = await redis.get(key);
+    const edge = raw ? JSON.parse(raw) : { from, to, edgeType, successes: 0, trials: 0, confidence: 0, last_updated: '' };
+    edge.trials = (edge.trials || 0) + 1;
+    if (success)
+        edge.successes = (edge.successes || 0) + 1;
+    else if (partial)
+        edge.successes = (edge.successes || 0) + 0.5;
+    // Beta distribution smoothed confidence: (successes+1) / (trials+2)
+    edge.confidence = (edge.successes + 1) / (edge.trials + 2);
+    edge.last_updated = new Date().toISOString();
+    await redis.set(key, JSON.stringify(edge));
+    // Index: set of edge keys per source node (for fast traversal)
+    await redis.sadd(`cachly:ckg:idx:from:${from}`, key);
+    await redis.sadd(`cachly:ckg:idx:to:${to}`, key);
+}
 // ── Tools ─────────────────────────────────────────────────────────────────────
 const TOOLS = [
     // ── Instance Management ──────────────────────────────────────────────────
@@ -2976,21 +3015,6 @@ const TOOLS = [
             required: ['instance_id'],
         },
     },
-    // ── crystal_view — inspect current Memory Crystal ──────────────────────
-    {
-        name: 'crystal_view',
-        description: 'View the current Memory Crystal — the distilled snapshot of everything your AI brain has learned. ' +
-            'Shows all top patterns grouped by category, lesson count, crystal age, and when to refresh. ' +
-            'A crystal is created by memory_crystalize and injected into every session_start automatically. ' +
-            'Call this to review what institutional knowledge is preserved, or to decide if a refresh is due.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                instance_id: { type: 'string', description: 'UUID of the cache instance' },
-            },
-            required: ['instance_id'],
-        },
-    },
     // ── Roadmap — Persistent project plan tracker ───────────────────────────
     {
         name: 'roadmap_add',
@@ -3480,58 +3504,50 @@ const TOOLS = [
             required: [],
         },
     },
-    // ── v0.9 — compact_recover ─────────────────────────────────────────────────
+    // ── Layer 1: Causal Knowledge Graph ────────────────────────────────────────
     {
-        name: 'compact_recover',
-        description: 'FAST context recovery after Claude/Cursor/Copilot context window compaction. ' +
-            'Call this as the FIRST tool call after any context limit hit or window restart — before reading any files. ' +
-            'Returns: last checkpoint (task + files + next_step), session handoff if any, last 5 recalled lessons, open TODOs. ' +
-            'Unlike session_start, this is instant — no full brain scan, no streak logic, just the critical recovery data. ' +
-            'Typical use in CLAUDE.md: "If context is compacted, call compact_recover immediately."',
+        name: 'brain_search',
+        description: 'BM25+ full-text search over ALL brain data: lessons, context entries, session history, CKG nodes, roadmap items. ' +
+            'Unlike smart_recall (which focuses on lessons + context), brain_search casts a wider net. ' +
+            'Use when smart_recall returns nothing or when you want to find anything the brain knows about a topic.',
         inputSchema: {
             type: 'object',
             properties: {
-                instance_id: { type: 'string', description: 'UUID of the cache instance' },
-                focus: {
-                    type: 'string',
-                    description: 'What you are trying to recover context for — used to surface relevant lessons (optional)',
-                },
+                instance_id: { type: 'string', description: 'Brain instance ID' },
+                query: { type: 'string', description: 'What to search for' },
+                limit: { type: 'number', description: 'Max results (default: 15)' },
             },
-            required: ['instance_id'],
+            required: ['instance_id', 'query'],
         },
     },
-    // ── v0.9 — brain_from_git ─────────────────────────────────────────────────
     {
-        name: 'brain_from_git',
-        description: 'Bootstrap the AI Brain from git history — reads commit messages and automatically stores lessons. ' +
-            'Scans the last N days of commits, extracts actionable knowledge (fixes, reverts, deploys, migrations), ' +
-            'and bulk-loads them into the Brain as lessons. ' +
-            'Run once to pre-load months of team knowledge before the first session_start. ' +
-            'Skips commits already in the Brain (safe to re-run). ' +
-            'Example: brain_from_git(instance_id="...", workspace_path="/home/you/project", days=180) ' +
-            '→ "📊 Scanned 342 commits · ✅ 28 lessons stored · ❌ 9 failure lessons · 0 duplicates skipped"',
+        name: 'ckg_inspect',
+        description: 'Inspect the Causal Knowledge Graph (CKG) for a concept. Shows all typed edges (fixes, requires, co-occurs, causes) ' +
+            'with Bayesian confidence scores. Use to understand what the brain knows about a topic and which fixes have the ' +
+            'highest confidence. Also shows related concepts via graph traversal.',
         inputSchema: {
             type: 'object',
             properties: {
-                instance_id: { type: 'string', description: 'UUID of the cache instance' },
-                workspace_path: {
-                    type: 'string',
-                    description: 'Absolute path to the git repository root (e.g. "/home/you/myproject")',
-                },
-                days: {
-                    type: 'number',
-                    description: 'How many days of history to scan (default: 180, max: 365)',
-                },
-                max_commits: {
-                    type: 'number',
-                    description: 'Maximum number of commits to process (default: 200, max: 500)',
-                },
-                author: {
-                    type: 'string',
-                    description: 'Filter to commits by this git author email or name (optional — omit to scan all authors)',
-                },
+                instance_id: { type: 'string', description: 'Brain instance ID' },
+                concept: { type: 'string', description: 'Concept to inspect, e.g. "fix:clickhouse-ipv6" or "docker"' },
+                max_hops: { type: 'number', description: 'Traversal depth (default: 2)' },
             },
-            required: ['instance_id', 'workspace_path'],
+            required: ['instance_id', 'concept'],
+        },
+    },
+    {
+        name: 'brain_predict',
+        description: 'Predictive Pre-fetch Engine (PPE): given your current context (what you\'re working on), traverses the CKG ' +
+            'to predict likely failures and pre-load relevant fixes. Returns top predicted pitfalls + highest-confidence fixes. ' +
+            'Call at session_start when working on a specific feature or debugging area.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance_id: { type: 'string', description: 'Brain instance ID' },
+                context: { type: 'string', description: 'What you\'re working on, e.g. "upgrading Keycloak from 21 to 24"' },
+                top_k: { type: 'number', description: 'Max predictions to return (default: 5)' },
+            },
+            required: ['instance_id', 'context'],
         },
     },
 ];
@@ -4442,6 +4458,46 @@ async function handleTool(name, args) {
                 await redis.ltrim(dlKey, -50, -1);
             }
             catch { /* non-critical */ }
+            // ── Layer 1+2: CKG update (Causal Knowledge Graph + Belief Update Engine) ──
+            try {
+                const conceptId = ckgSlug(topic);
+                const domain = topic.split(':')[0] ?? 'unknown';
+                const conceptType = domain; // fix, debug, deploy, infra, api, etc.
+                // Upsert concept node
+                await ckgUpsertNode(redis, conceptId, domain, conceptType);
+                // Tag co-occurrence edges
+                for (const tag of tags) {
+                    const tagId = ckgSlug(`tag:${tag}`);
+                    await ckgUpsertNode(redis, tagId, 'tag', 'tag');
+                    await ckgUpdateEdge(redis, conceptId, 'co-occurs', tagId, outcome === 'success', outcome === 'partial');
+                }
+                // depends_on → requires edges (structural, always confidence 1.0 direction)
+                for (const dep of depends_on) {
+                    const depId = ckgSlug(dep);
+                    await ckgUpdateEdge(redis, conceptId, 'requires', depId, true);
+                }
+                // fixes edge: if category=fix and outcome=success, link to problem concept
+                if ((domain === 'fix' || domain === 'debug') && (outcome === 'success' || outcome === 'partial')) {
+                    const problemText = what_failed || ctx || '';
+                    const problemConcept = problemText ? extractProblemConcept(problemText) : null;
+                    if (problemConcept) {
+                        const problemId = ckgSlug(`problem:${problemConcept}`);
+                        await ckgUpsertNode(redis, problemId, 'problem', 'problem');
+                        await ckgUpdateEdge(redis, conceptId, 'fixes', problemId, outcome === 'success', outcome === 'partial');
+                    }
+                }
+                // causes edge: if outcome=failure, link topic concept to the problem context
+                if (outcome === 'failure' && (what_failed || what_worked)) {
+                    const causeText = what_failed || what_worked;
+                    const causeConcept = extractProblemConcept(causeText);
+                    if (causeConcept) {
+                        const causeId = ckgSlug(`cause:${causeConcept}`);
+                        await ckgUpsertNode(redis, causeId, 'cause', 'cause');
+                        await ckgUpdateEdge(redis, conceptId, 'causes', causeId, false);
+                    }
+                }
+            }
+            catch { /* CKG updates are non-critical */ }
             const emoji = outcome === 'success' ? '✅' : outcome === 'partial' ? '⚠️' : '❌';
             const sevEmoji = severity === 'critical' ? '🔴' : severity === 'major' ? '🟡' : '🟢';
             const action = isUpdate ? 'updated' : 'stored';
@@ -4917,7 +4973,37 @@ async function handleTool(name, args) {
             }
             // Brain health
             lines.push(`📊 **Brain:** ${lessons.length} lessons · ${ctxCount} context entries`, '');
-            // Focus-relevant lessons
+            // ── Layer 7: MCM Domain Coverage Map ────────────────────────────────────
+            if (lessons.length >= 3) {
+                const domainMap = new Map();
+                for (const l of lessons) {
+                    const dom = l.topic.split(':')[0] ?? 'other';
+                    if (!domainMap.has(dom))
+                        domainMap.set(dom, { total: 0, success: 0, critical: 0 });
+                    const d = domainMap.get(dom);
+                    d.total++;
+                    if (l.outcome === 'success')
+                        d.success++;
+                    if (l.severity === 'critical')
+                        d.critical++;
+                }
+                const sorted = [...domainMap.entries()].sort((a, b) => b[1].total - a[1].total).slice(0, 6);
+                const hasContestedDomains = sorted.some(([, d]) => d.success < d.total * 0.4 && d.total >= 2);
+                if (sorted.length > 0) {
+                    lines.push(`🗺️ **Knowledge Coverage:**`);
+                    for (const [dom, d] of sorted) {
+                        const pct = Math.round((d.success / d.total) * 100);
+                        const filled = Math.round(pct / 10);
+                        const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+                        const flag = d.critical > 0 ? ' 🔴' : pct < 40 && d.total >= 2 ? ' ⚠️' : '';
+                        lines.push(`  ${bar} ${dom.padEnd(18)} ${String(pct).padStart(3)}% (${d.success}/${d.total} confirmed)${flag}`);
+                    }
+                    if (hasContestedDomains) {
+                        lines.push(`  ⚠️ _Some domains have contested beliefs — use \`ckg_inspect\` to review_`);
+                    }
+                    lines.push('');
+                }
+            }
             if (focusLessons.length > 0) {
                 lines.push(`🎯 **Relevant for "${focus}":**`);
                 for (const l of focusLessons.slice(0, 4)) {
@@ -5255,22 +5341,6 @@ async function handleTool(name, args) {
                 }
                 catch { /* git not available or not a repo — silent skip */ }
             }
-            // ── Crystal age check — remind if > 30 days old or missing ──────────────
-            let crystalReminder = '';
-            try {
-                const crystalRaw = await redis.get('cachly:crystal:latest');
-                if (!crystalRaw) {
-                    crystalReminder = `💎 **Memory Crystal:** None exists yet. Run \`memory_crystalize(instance_id="${instance_id}")\` to distill your brain into a permanent snapshot — injected into every future session automatically.`;
-                }
-                else {
-                    const crystal = JSON.parse(crystalRaw);
-                    const crystalAgeDays = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
-                    if (crystalAgeDays >= 30) {
-                        crystalReminder = `💎 **Memory Crystal is ${crystalAgeDays} days old** (${crystal.label ?? 'unnamed'}). Run \`memory_crystalize(instance_id="${instance_id}")\` to refresh it with your latest ${crystal.lesson_count ?? '?'} lessons.`;
-                    }
-                }
-            }
-            catch { /* non-critical */ }
             const durationStr = durationMin !== undefined ? ` · ${durationMin} min` : '';
             return [
                 `✅ **Session saved**${durationStr}`,
@@ -5280,7 +5350,6 @@ async function handleTool(name, args) {
                 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 ? '…' : ''})` : '',
-                crystalReminder,
                 ``,
                 `💡 Next session: \`session_start(focus="...")\` to see this summary.`,
             ].filter(l => l !== '').join('\n');
@@ -5669,52 +5738,6 @@ async function handleTool(name, args) {
             ];
             return lines.join('\n');
         }
-        // ── crystal_view — show current Memory Crystal ───────────────────────────
-        case 'crystal_view': {
-            const { instance_id } = args;
-            const redis = await getConnection(instance_id);
-            const crystalRaw = await redis.get('cachly:crystal:latest');
-            if (!crystalRaw) {
-                return [
-                    `💎 **No Memory Crystal yet**`,
-                    ``,
-                    `Your brain has no crystal — all knowledge lives in raw lessons only.`,
-                    ``,
-                    `Run \`memory_crystalize(instance_id="${instance_id}")\` to:`,
-                    `  • Distill everything learned into a permanent, compact snapshot`,
-                    `  • Inject it into every future \`session_start\` automatically`,
-                    `  • Preserve team knowledge even after lesson TTLs expire`,
-                    ``,
-                    `💡 Recommended: run monthly or after any major milestone.`,
-                ].join('\n');
-            }
-            const crystal = JSON.parse(crystalRaw);
-            const ageDays = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
-            const ageStr = ageDays === 0 ? 'today' : ageDays === 1 ? '1 day ago' : `${ageDays} days ago`;
-            const freshness = ageDays < 14 ? '🟢 Fresh' : ageDays < 30 ? '🟡 Aging' : '🔴 Stale — refresh recommended';
-            const lines = [
-                `💎 **Memory Crystal: ${crystal.label}**`,
-                ``,
-                `📅 Created: **${ageStr}** · Freshness: ${freshness}`,
-                `📊 Compressed: **${crystal.session_count} sessions** + **${crystal.lesson_count} lessons** → ${crystal.top_patterns.length} patterns`,
-                `🗂️  Categories: ${crystal.categories.slice(0, 10).join(', ')}${crystal.categories.length > 10 ? `… +${crystal.categories.length - 10}` : ''}`,
-                ``,
-                `**Top patterns by category:**`,
-                ``,
-            ];
-            for (const p of crystal.top_patterns) {
-                lines.push(`**${p.category}** (${p.count} lesson${p.count > 1 ? 's' : ''})`);
-                lines.push(`  → ${p.insight.slice(0, 150)}${p.insight.length > 150 ? '…' : ''}`);
-                lines.push('');
-            }
-            if (ageDays >= 30) {
-                lines.push(`---`, `⚠️ Crystal is ${ageDays} days old. Run \`memory_crystalize(instance_id="${instance_id}")\` to refresh with your latest lessons.`);
-            }
-            else {
-                lines.push(`---`, `💡 This crystal is injected automatically into every \`session_start\`. Refresh monthly with \`memory_crystalize\`.`);
-            }
-            return lines.filter(l => l !== undefined).join('\n');
-        }
         case 'brain_doctor': {
             const { instance_id, workspace_path: drWorkspacePath = '' } = args;
             const redis = await getConnection(instance_id);
@@ -6944,7 +6967,59 @@ async function handleBulkLockStream(name, args) {
                 .replace(/[^a-z0-9\s\-_:]/g, ' ')
                 .split(/\s+/)
                 .filter(t => t.length > 2);
-            // Scan all lessons + history entries
+            const SEV_ICON = { critical: '🔴', major: '🟠', minor: '🟡' };
+            const ckgResults = [];
+            try {
+                for (const token of tokens.slice(0, 4)) {
+                    // Search for CKG nodes matching this token
+                    const fromKeys = await redis.smembers(`cachly:ckg:idx:from:${ckgSlug(token)}`);
+                    const toKeys = await redis.smembers(`cachly:ckg:idx:to:${ckgSlug(token)}`);
+                    // Also try pattern: scan nodes containing the token
+                    const nodeKeys = [];
+                    const nStream = redis.scanStream({ match: `cachly:ckg:node:*${token}*`, count: 50 });
+                    await new Promise((res, rej) => { nStream.on('data', (b) => nodeKeys.push(...b)); nStream.on('end', res); nStream.on('error', rej); });
+                    for (const nodeKey of nodeKeys.slice(0, 10)) {
+                        const nodeRaw = await redis.get(nodeKey);
+                        if (!nodeRaw)
+                            continue;
+                        const node = JSON.parse(nodeRaw);
+                        // Get edges from this node
+                        const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${node.id}`);
+                        for (const ek of edgeKeys.slice(0, 20)) {
+                            const edgeRaw = await redis.get(ek);
+                            if (!edgeRaw)
+                                continue;
+                            const edge = JSON.parse(edgeRaw);
+                            if (edge.edgeType !== 'fixes' && edge.edgeType !== 'requires')
+                                continue;
+                            // Find lesson for this concept
+                            const lessonRaw = await redis.get(`cachly:lesson:best:${edge.from.replace(/-/g, ':').replace(/^fix:/, 'fix:')}`);
+                            const lesson = lessonRaw ? JSON.parse(lessonRaw) : undefined;
+                            ckgResults.push({ conceptId: node.id, edge, lesson });
+                        }
+                    }
+                    for (const ek of [...fromKeys, ...toKeys].slice(0, 20)) {
+                        const edgeRaw = await redis.get(ek);
+                        if (!edgeRaw)
+                            continue;
+                        const edge = JSON.parse(edgeRaw);
+                        const lessonRaw = await redis.get(`cachly:lesson:best:${edge.from}`);
+                        const lesson = lessonRaw ? JSON.parse(lessonRaw) : undefined;
+                        ckgResults.push({ conceptId: edge.from, edge, lesson });
+                    }
+                }
+            }
+            catch { /* CKG traversal non-critical */ }
+            // Deduplicate CKG results and sort by confidence
+            const ckgSeen = new Set();
+            const ckgDeduped = ckgResults.filter(r => {
+                const key = `${r.edge.from}:${r.edge.edgeType}:${r.edge.to}`;
+                if (ckgSeen.has(key))
+                    return false;
+                ckgSeen.add(key);
+                return true;
+            }).sort((a, b) => b.edge.confidence - a.edge.confidence).slice(0, max_depth);
+            // ── Layer 2 (fallback): text similarity over all lessons ─────────────────
             let cursor = 0;
             const lessonKeys = [];
             do {
@@ -6960,7 +7035,6 @@ async function handleBulkLockStream(name, args) {
                     continue;
                 try {
                     const l = JSON.parse(raw);
-                    // Skip if filter tags given and lesson has none of them
                     if (filterTags.length > 0 && !(l.tags ?? []).some((t) => filterTags.includes(t)))
                         continue;
                     const haystack = [l.topic, l.what_failed ?? '', l.what_worked ?? '', l.context ?? '']
@@ -6973,7 +7047,7 @@ async function handleBulkLockStream(name, args) {
             }
             scored.sort((a, b) => b.score - a.score);
             const chain = scored.slice(0, max_depth);
-            if (chain.length === 0) {
+            if (chain.length === 0 && ckgDeduped.length === 0) {
                 return [
                     `🔍 **Causal Trace: "${problem}"**`,
                     ``,
@@ -6991,50 +7065,64 @@ async function handleBulkLockStream(name, args) {
                     `\`\`\``,
                 ].join('\n');
             }
-            // Build causal chain narrative: failures first → then successes
-            const failures = chain.filter(c => c.lesson.outcome !== 'success');
-            const solutions = chain.filter(c => c.lesson.outcome === 'success');
-            const SEV_ICON = { critical: '🔴', major: '🟠', minor: '🟡' };
             const lines = [
                 `🔍 **Causal Trace: "${problem}"**`,
                 ``,
-                `Found **${chain.length}** related lessons. Reconstructed causal chain:`,
-                ``,
             ];
-            if (failures.length > 0) {
-                lines.push(`**Root causes & failure chain:**`);
-                failures.forEach((c, i) => {
-                    const l = c.lesson;
-                    const sev = SEV_ICON[l.severity ?? 'minor'] ?? '🟡';
-                    lines.push(`${i === 0 ? '  Root:' : '   → :'} ${sev} \`${l.topic}\``);
-                    if (l.what_failed)
-                        lines.push(`          ↳ ${l.what_failed.slice(0, 120)}`);
-                });
-                lines.push('');
-            }
-            if (solutions.length > 0) {
-                lines.push(`**Solutions that worked before:**`);
-                solutions.forEach((c, i) => {
-                    const l = c.lesson;
-                    const date = new Date(l.ts).toLocaleDateString('de-DE');
-                    lines.push(`  ${i + 1}. ✅ \`${l.topic}\` — ${date} · recalled ${l.recall_count ?? 0}× `);
-                    if (l.what_worked)
-                        lines.push(`     ${l.what_worked.slice(0, 200)}`);
-                });
-                lines.push('');
+            // Show CKG graph results first if available
+            if (ckgDeduped.length > 0) {
+                lines.push(`### 🕸️ CKG Graph (confidence-ranked)`);
+                for (const r of ckgDeduped) {
+                    const confPct = Math.round(r.edge.confidence * 100);
+                    const confBar = '▓'.repeat(Math.round(confPct / 10)) + '░'.repeat(10 - Math.round(confPct / 10));
+                    lines.push(`  ${r.edge.from} **→[${r.edge.edgeType}]→** ${r.edge.to}`);
+                    lines.push(`  ${confBar} ${confPct}% confidence (${r.edge.successes}/${r.edge.trials} confirmed)`);
+                    if (r.lesson?.what_worked)
+                        lines.push(`  ✅ Fix: ${r.lesson.what_worked.slice(0, 150)}`);
+                    lines.push('');
+                }
             }
-            const topSolution = solutions[0]?.lesson;
-            if (topSolution?.what_worked) {
-                lines.push(`**⚡ Most likely fix:**`);
-                lines.push(`\`\`\``);
-                lines.push(topSolution.what_worked.slice(0, 500));
-                lines.push(`\`\`\``);
-                lines.push('');
+            // Build text-based causal chain narrative
+            if (chain.length > 0) {
+                lines.push(ckgDeduped.length > 0 ? `### 📚 Text Search (${chain.length} related lessons)` : `Found **${chain.length}** related lessons. Reconstructed causal chain:`, '');
+                const failures = chain.filter(c => c.lesson.outcome !== 'success');
+                const solutions = chain.filter(c => c.lesson.outcome === 'success');
+                if (failures.length > 0) {
+                    lines.push(`**Root causes & failure chain:**`);
+                    failures.forEach((c, i) => {
+                        const l = c.lesson;
+                        const sev = SEV_ICON[l.severity ?? 'minor'] ?? '🟡';
+                        lines.push(`${i === 0 ? '  Root:' : '   → :'} ${sev} \`${l.topic}\``);
+                        if (l.what_failed)
+                            lines.push(`          ↳ ${l.what_failed.slice(0, 120)}`);
+                    });
+                    lines.push('');
+                }
+                if (solutions.length > 0) {
+                    lines.push(`**Solutions that worked before:**`);
+                    solutions.forEach((c, i) => {
+                        const l = c.lesson;
+                        const date = new Date(l.ts).toLocaleDateString('de-DE');
+                        lines.push(`  ${i + 1}. ✅ \`${l.topic}\` — ${date} · recalled ${l.recall_count ?? 0}×`);
+                        if (l.what_worked)
+                            lines.push(`     ${l.what_worked.slice(0, 200)}`);
+                    });
+                    lines.push('');
+                }
+                const topSolution = solutions[0]?.lesson;
+                if (topSolution?.what_worked) {
+                    lines.push(`**⚡ Most likely fix:**`);
+                    lines.push(`\`\`\``);
+                    lines.push(topSolution.what_worked.slice(0, 500));
+                    lines.push(`\`\`\``);
+                    lines.push('');
+                }
             }
             lines.push(`💡 After applying: \`learn_from_attempts(topic="fix:${tokens[0] ?? 'issue'}", outcome="success", ...)\``);
+            if (ckgDeduped.length > 0)
+                lines.push(`🕸️ Explore graph: \`ckg_inspect(concept="${tokens[0] ?? 'fix'}")\``);
             return lines.join('\n');
         }
-        // ── v0.6 Cognitive Cache: knowledge_decay ────────────────────────────────
         case 'knowledge_decay': {
             const { instance_id, min_age_days = 0, show_top = 20 } = args;
             const redis = await getConnection(instance_id);
@@ -7114,11 +7202,9 @@ async function handleBulkLockStream(name, args) {
 > Sessions are fully automatic. The Brain starts when you call any tool and saves a summary when you close.
 
 ### MANDATORY hooks (always fire, no exceptions):
-- **Context compacted** → call \`compact_recover(instance_id="${instance_id}", focus="<current task>")\` FIRST
 - **Window opens** → call \`session_start(instance_id="${instance_id}", focus="<today's goal>")\`
 - **Bug fixed / deployed / discovered** → call \`learn_from_attempts(instance_id="${instance_id}", topic="fix:<area>", outcome="success", what_worked="...")\`
 - **Window closes** → call \`session_end(instance_id="${instance_id}", summary="...", files_changed=[...])\`
-- **Monthly** → call \`memory_crystalize(instance_id="${instance_id}")\` to distill knowledge into a permanent Crystal
 `;
             const full = `## Cachly AI Brain — Autopilot for ${project_name}
 
@@ -7178,40 +7264,18 @@ smart_recall(
 
 ---
 
-## ⚡ Context Recovery (MANDATORY after compaction)
-
-**If your context window was compacted**, call this FIRST — before reading any file:
-\`\`\`
-compact_recover(
-  instance_id = "${instance_id}",
-  focus       = "<what you were working on>",
-)
-\`\`\`
-Returns: last checkpoint, pending tasks, top lessons. Instant — no full brain scan.
-
----
-
-## 🔁 Scheduled Maintenance (run on schedule)
-
-| When | Call |
-|---|---|
-| **Monthly** | \`memory_crystalize(instance_id="${instance_id}")\` — distill brain into a permanent snapshot |
-| Weekly review | \`brain_diff(instance_id="${instance_id}", since="7d")\` — see what your AI learned this week |
-| Before big refactor | \`knowledge_decay(instance_id="${instance_id}")\` — see which lessons to still trust |
-| After major milestone | \`memory_crystalize(instance_id="${instance_id}", label="v2 launch")\` — preserve milestone knowledge |
-
-## 🧠 Cognitive Tools (use anytime)
+## ⚡ Cognitive Tools (v0.6)
 
 | When | Call |
 |---|---|
 | Brain feeling cluttered | \`memory_consolidate(instance_id="${instance_id}")\` |
+| Weekly review | \`brain_diff(instance_id="${instance_id}", since="7d")\` |
 | Weird bug, no idea why | \`causal_trace(instance_id="${instance_id}", problem="<symptom>")\` |
-| Unknown error | \`syndicate_search(q="<error message>")\` — global community solutions |
-| Unknown error that you solved | \`syndicate(instance_id="${instance_id}", topic="fix:<area>", what_worked="...")\` |
+| Before big refactor | \`knowledge_decay(instance_id="${instance_id}")\` |
 
 ---
 
-*Cachly v0.9 · Generated ${new Date().toISOString().slice(0, 10)}*
+*Cachly v0.6 · Generated ${new Date().toISOString().slice(0, 10)}*
 `;
             const content = style === 'minimal' ? minimal : full;
             const filename = editor === 'copilot'
@@ -7370,172 +7434,198 @@ Returns: last checkpoint, pending tasks, top lessons. Instant — no full brain
             lines.push(`---`, `**Confirm** (if this helped you): \`syndicate(topic="${res.results[0]?.topic ?? '...'}", what_worked="...")\` → auto-deduped, trust +1`, `**All trending:** \`syndicate_trending(limit=50)\`  |  **Search:** \`syndicate_search(q="...")\``);
             return lines.filter(l => l !== '').join('\n');
         }
-        // ── v0.9 compact_recover — fast context recovery ──────────────────────────
-        case 'compact_recover': {
-            const { instance_id, focus = '' } = args;
+        // ── Layer 1: brain_search ─────────────────────────────────────────────────
+        case 'brain_search': {
+            const { instance_id, query, limit = 15 } = args;
             const redis = await getConnection(instance_id);
-            const lines = ['⚡ **Context Recovered**', ''];
-            // 1. Latest checkpoint
-            const checkpointRaw = await redis.get('cachly:session:checkpoint');
-            if (checkpointRaw) {
-                try {
-                    const cp = JSON.parse(checkpointRaw);
-                    const ago = Math.round((Date.now() - new Date(cp.ts).getTime()) / 60000);
-                    const agoStr = ago < 60 ? `${ago}m ago` : `${Math.round(ago / 60)}h ago`;
-                    lines.push(`📌 **Last checkpoint** (${agoStr}): ${cp.task}`);
-                    if (cp.files_touched && cp.files_touched.length > 0) {
-                        lines.push(`   Files: ${cp.files_touched.slice(0, 5).join(', ')}${cp.files_touched.length > 5 ? '…' : ''}`);
+            // BM25+ over ALL brain key namespaces
+            const allMatches = await keywordSearch(redis, [
+                'cachly:lesson:best:*',
+                'cachly:ctx:*',
+                'cachly:idx:*',
+                'cachly:session:last',
+                'cachly:session:handoff',
+                'cachly:roadmap:*',
+                'cachly:ckg:node:*',
+            ], query, limit);
+            if (allMatches.length === 0) {
+                return [`🔎 **Brain Search: "${query}"**`, '', `No results found across all brain data.`, '', `💡 Try \`smart_recall\` or check \`list_remembered\`.`].join('\n');
+            }
+            const lines = [`🔎 **Brain Search: "${query}"** — ${allMatches.length} result${allMatches.length !== 1 ? 's' : ''} across all brain data\n`];
+            for (const m of allMatches.slice(0, limit)) {
+                const ns = m.key.startsWith('cachly:lesson:') ? '💡 lesson'
+                    : m.key.startsWith('cachly:ctx:') ? '📝 context'
+                        : m.key.startsWith('cachly:idx:') ? '📂 index'
+                            : m.key.startsWith('cachly:session:') ? '🕐 session'
+                                : m.key.startsWith('cachly:roadmap:') ? '🗺️ roadmap'
+                                    : m.key.startsWith('cachly:ckg:node:') ? '🕸️ ckg-node'
+                                        : '🗄️ data';
+                const preview = m.content.slice(0, 280).replace(/\n/g, ' ');
+                lines.push(`**${ns}** \`${m.key.split(':').slice(2).join(':')}\` _(BM25: ${m.score.toFixed(2)})_`);
+                lines.push(`> ${preview}${m.content.length > 280 ? '…' : ''}\n`);
+            }
+            return lines.join('\n');
+        }
+        // ── Layer 1: ckg_inspect ─────────────────────────────────────────────────
+        case 'ckg_inspect': {
+            const { instance_id, concept, max_hops = 2 } = args;
+            const redis = await getConnection(instance_id);
+            const conceptId = ckgSlug(concept);
+            const visited = new Set();
+            const allEdges = [];
+            // BFS traversal of CKG
+            const queue = [{ id: conceptId, hop: 0 }];
+            while (queue.length > 0) {
+                const { id, hop } = queue.shift();
+                if (visited.has(id) || hop > max_hops)
+                    continue;
+                visited.add(id);
+                const fromKeys = await redis.smembers(`cachly:ckg:idx:from:${id}`);
+                const toKeys = await redis.smembers(`cachly:ckg:idx:to:${id}`);
+                for (const ek of [...fromKeys, ...toKeys].slice(0, 50)) {
+                    const raw = await redis.get(ek);
+                    if (!raw)
+                        continue;
+                    const edge = JSON.parse(raw);
+                    allEdges.push(edge);
+                    if (hop < max_hops) {
+                        if (!visited.has(edge.from))
+                            queue.push({ id: edge.from, hop: hop + 1 });
+                        if (!visited.has(edge.to))
+                            queue.push({ id: edge.to, hop: hop + 1 });
                     }
-                    if (cp.next_step)
-                        lines.push(`📍 **Resume with:** ${cp.next_step}`);
-                    lines.push('');
                 }
-                catch { /* ignore corrupt */ }
             }
-            // 2. Handoff (if any, from a different window)
-            const handoffRaw = await redis.get('cachly:session:handoff');
-            if (handoffRaw) {
-                try {
-                    const hf = JSON.parse(handoffRaw);
-                    const remaining = hf.remaining_tasks ?? [];
-                    if (remaining.length > 0) {
-                        lines.push(`⏳ **Remaining tasks:**`);
-                        remaining.slice(0, 5).forEach(t => lines.push(`  - ${t}`));
-                        if (remaining.length > 5)
-                            lines.push(`  …and ${remaining.length - 5} more`);
-                        lines.push('');
-                    }
-                    if (hf.blocked_on) {
-                        lines.push(`🚫 **Blocked on:** ${hf.blocked_on}`, '');
+            if (allEdges.length === 0) {
+                // Try fuzzy: scan for nodes matching the concept as substring
+                const nodeKeys = [];
+                const nStream = redis.scanStream({ match: `cachly:ckg:node:*${conceptId}*`, count: 100 });
+                await new Promise((res, rej) => { nStream.on('data', (b) => nodeKeys.push(...b)); nStream.on('end', res); nStream.on('error', rej); });
+                if (nodeKeys.length === 0) {
+                    return [`🕸️ **CKG Inspect: "${concept}"**`, '', `No CKG nodes found. The graph builds automatically as you call \`learn_from_attempts\`.`, '', `💡 Once you have lessons stored, CKG edges will appear here.`].join('\n');
+                }
+                const nodeList = nodeKeys.slice(0, 10).map(k => `  • \`${k.replace('cachly:ckg:node:', '')}\``).join('\n');
+                return [`🕸️ **CKG Inspect: "${concept}"**`, '', `No edges found for \`${conceptId}\`, but found similar nodes:`, nodeList, '', `Try: \`ckg_inspect(concept="<exact-node-id>")\``].join('\n');
+            }
+            // Sort by confidence desc, deduplicate
+            const edgeSeen = new Set();
+            const unique = allEdges.filter(e => {
+                const k = `${e.from}:${e.edgeType}:${e.to}`;
+                if (edgeSeen.has(k))
+                    return false;
+                edgeSeen.add(k);
+                return true;
+            }).sort((a, b) => b.confidence - a.confidence);
+            const EDGE_ICON = { fixes: '🔧', requires: '🔗', 'co-occurs': '🔄', causes: '⚡', contradicts: '⚠️', degrades_under: '📉' };
+            const lines = [`🕸️ **CKG Inspect: "${concept}"** (${unique.length} edge${unique.length !== 1 ? 's' : ''}, ${visited.size} node${visited.size !== 1 ? 's' : ''} traversed)\n`];
+            // Group by edge type
+            const byType = new Map();
+            for (const e of unique) {
+                if (!byType.has(e.edgeType))
+                    byType.set(e.edgeType, []);
+                byType.get(e.edgeType).push(e);
+            }
+            for (const [eType, edges] of byType) {
+                const icon = EDGE_ICON[eType] ?? '→';
+                lines.push(`**${icon} ${eType}** (${edges.length})`);
+                for (const e of edges.slice(0, 8)) {
+                    const confPct = Math.round(e.confidence * 100);
+                    const bar = '▓'.repeat(Math.round(confPct / 10)) + '░'.repeat(10 - Math.round(confPct / 10));
+                    lines.push(`  \`${e.from}\` → \`${e.to}\`  ${bar} ${confPct}% (${e.successes.toFixed(1)}/${e.trials} trials)`);
+                }
+                lines.push('');
+            }
+            lines.push(`💡 Expand: \`ckg_inspect(concept="${concept}", max_hops=3)\`  |  Predict: \`brain_predict(context="${concept}")\``);
+            return lines.join('\n');
+        }
+        // ── Layer 4: brain_predict (PPE) ─────────────────────────────────────────
+        case 'brain_predict': {
+            const { instance_id, context: ctx, top_k = 5 } = args;
+            const redis = await getConnection(instance_id);
+            const ctxTokens = ctx.toLowerCase().replace(/[^a-z0-9\s\-_:]/g, ' ').split(/\s+/).filter(t => t.length > 2);
+            const predictions = [];
+            for (const token of ctxTokens.slice(0, 6)) {
+                const nodeKeys = [];
+                const nStream = redis.scanStream({ match: `cachly:ckg:node:*${token}*`, count: 50 });
+                await new Promise((res, rej) => { nStream.on('data', (b) => nodeKeys.push(...b)); nStream.on('end', res); nStream.on('error', rej); });
+                for (const nk of nodeKeys.slice(0, 5)) {
+                    const nodeRaw = await redis.get(nk);
+                    if (!nodeRaw)
+                        continue;
+                    const node = JSON.parse(nodeRaw);
+                    const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${node.id}`);
+                    for (const ek of edgeKeys.slice(0, 20)) {
+                        const edgeRaw = await redis.get(ek);
+                        if (!edgeRaw)
+                            continue;
+                        const edge = JSON.parse(edgeRaw);
+                        // Only interested in fixes and co-occurs for prediction
+                        if (edge.edgeType !== 'fixes' && edge.edgeType !== 'co-occurs' && edge.edgeType !== 'causes')
+                            continue;
+                        const lessonRaw = await redis.get(`cachly:lesson:best:${edge.from}`);
+                        const lesson = lessonRaw ? JSON.parse(lessonRaw) : undefined;
+                        predictions.push({ concept: node.id, edgeType: edge.edgeType, target: edge.to, confidence: edge.confidence, lesson });
                     }
                 }
-                catch { /* ignore */ }
             }
-            // 3. Top recently recalled lessons (BM25 if focus, else recency)
+            // Step 2: Text-based fallback — scan lessons for matching topics
+            const textPredictions = [];
             const lessonKeys = [];
             const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-            await new Promise((resolve, reject) => {
-                lStream.on('data', (batch) => lessonKeys.push(...batch));
-                lStream.on('end', resolve);
-                lStream.on('error', reject);
-            });
-            const allLessons = [];
+            await new Promise((res, rej) => { lStream.on('data', (b) => lessonKeys.push(...b)); lStream.on('end', res); lStream.on('error', rej); });
             for (const k of lessonKeys) {
                 const raw = await redis.get(k);
                 if (!raw)
                     continue;
                 try {
-                    allLessons.push(JSON.parse(raw));
+                    const l = JSON.parse(raw);
+                    const haystack = [l.topic, l.what_failed ?? '', l.what_worked ?? ''].join(' ').toLowerCase();
+                    const score = ctxTokens.reduce((s, t) => s + (haystack.includes(t) ? 1 : 0), 0);
+                    if (score >= 1 && l.outcome !== 'failure') {
+                        const conf = calculateConfidence(l);
+                        textPredictions.push({ ...l, confidence: conf });
+                    }
                 }
                 catch { /* skip */ }
             }
-            const focusTerms = focus.toLowerCase().split(/\s+/).filter(Boolean);
-            let topLessons = focusTerms.length > 0
-                ? allLessons.filter(l => focusTerms.some(t => l.topic.toLowerCase().includes(t) || (l.tags ?? []).some((tag) => tag.toLowerCase().includes(t)))).slice(0, 5)
-                : allLessons.sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0)).slice(0, 5);
-            if (topLessons.length > 0) {
-                lines.push(`🧠 **Top lessons${focus ? ` for "${focus}"` : ''}:**`);
-                for (const l of topLessons) {
-                    const icon = l.outcome === 'success' ? '✅' : l.outcome === 'failure' ? '❌' : '⚠️';
-                    lines.push(`  ${icon} \`${l.topic}\` — ${l.what_worked.slice(0, 120)}${l.what_worked.length > 120 ? '…' : ''}`);
+            textPredictions.sort((a, b) => b.confidence - a.confidence);
+            if (predictions.length === 0 && textPredictions.length === 0) {
+                return [
+                    `🔮 **Brain Predict: "${ctx}"**`,
+                    ``,
+                    `No predictions yet — the brain hasn't seen this domain.`,
+                    ``,
+                    `💡 As you solve problems in this area and call \`learn_from_attempts\`, the CKG builds up and predictions become available.`,
+                ].join('\n');
+            }
+            const lines = [`🔮 **Brain Predict: "${ctx}"**\n`];
+            // CKG-based predictions
+            if (predictions.length > 0) {
+                const pSeen = new Set();
+                const pUniq = predictions.filter(p => { const k = `${p.concept}:${p.edgeType}:${p.target}`; if (pSeen.has(k))
+                    return false; pSeen.add(k); return true; })
+                    .sort((a, b) => b.confidence - a.confidence).slice(0, top_k);
+                lines.push(`### 🕸️ CKG Predictions (based on ${pUniq.length} known edges)`);
+                for (const p of pUniq) {
+                    const confPct = Math.round(p.confidence * 100);
+                    const icon = p.edgeType === 'fixes' ? '🔧' : p.edgeType === 'co-occurs' ? '🔄' : '⚡';
+                    lines.push(`${icon} **${confPct}%** \`${p.concept}\` _${p.edgeType}_ \`${p.target}\``);
+                    if (p.lesson?.what_worked)
+                        lines.push(`   ✅ ${p.lesson.what_worked.slice(0, 120)}`);
                 }
                 lines.push('');
             }
-            lines.push(`💡 Call \`session_start\` for the full briefing, or resume work directly.`);
-            return lines.filter(l => l !== '').join('\n');
-        }
-        // ── v0.9 brain_from_git — bulk-load git history as lessons ───────────────
-        case 'brain_from_git': {
-            const { instance_id, workspace_path, days = 180, max_commits = 200, author = '', } = args;
-            const redis = await getConnection(instance_id);
-            const { execSync } = await import('node:child_process');
-            const clampedDays = Math.min(Math.max(1, days), 365);
-            const clampedMax = Math.min(Math.max(1, max_commits), 500);
-            const authorArg = author ? `--author="${author}"` : '';
-            let gitRaw = '';
-            try {
-                gitRaw = execSync(`git -C "${workspace_path}" log --since="${clampedDays} days ago" ${authorArg} --oneline --format="%H|||%s|||%ai|||%ae" -n ${clampedMax}`, { timeout: 15000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-            }
-            catch {
-                return `❌ **brain_from_git failed**: Could not read git log from \`${workspace_path}\`.\nMake sure the path exists and is a git repository.`;
-            }
-            if (!gitRaw) {
-                return `📭 **No commits found** in the last ${clampedDays} days${author ? ` by "${author}"` : ''}.\nTry increasing \`days\` or removing the \`author\` filter.`;
-            }
-            const commitLines = gitRaw.split('\n');
-            const now = new Date();
-            const actionRe = /\b(fix|add|remove|refactor|migrate|update|resolve|implement|improve|optimize|configure|create|delete|disable|enable|debug|patch|upgrade|rewrite|deploy|feat|revert|break|merge|bump)\b/i;
-            const failRe = /\b(revert|broken|broke|breaking|rollback|undo|hotfix|crash|oops|wrong|mistake|bad)\b/i;
-            let stored = 0;
-            let skipped = 0;
-            let failures = 0;
-            const topLessons = [];
-            for (const line of commitLines) {
-                const parts = line.split('|||');
-                if (parts.length < 2)
-                    continue;
-                const [hash, msg, dateStr] = parts;
-                if (!msg || !actionRe.test(msg))
-                    continue;
-                const isFail = failRe.test(msg);
-                const cleanMsg = msg
-                    .replace(/^(fix|feat|chore|docs|test|ci|perf|refactor|build|revert|hotfix|bump)[:(\s!]+/i, '')
-                    .trim();
-                if (!cleanMsg || cleanMsg.length < 5)
-                    continue;
-                const slug = cleanMsg
-                    .toLowerCase()
-                    .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) {
-                    skipped++;
-                    continue;
+            // Text-based lesson predictions
+            if (textPredictions.length > 0) {
+                lines.push(`### 📚 Relevant Lessons (${Math.min(textPredictions.length, top_k)} pre-loaded)`);
+                for (const l of textPredictions.slice(0, top_k)) {
+                    const confPct = Math.round(l.confidence * 100);
+                    lines.push(`  ✅ **${confPct}%** \`${l.topic}\` — ${(l.what_worked ?? '').slice(0, 120)}`);
                 }
-                const lesson = {
-                    topic,
-                    outcome: isFail ? 'failure' : 'success',
-                    what_worked: isFail ? '' : cleanMsg.slice(0, 300),
-                    what_failed: isFail ? cleanMsg.slice(0, 300) : undefined,
-                    context: `Auto-learned from git commit ${(hash ?? '').slice(0, 7)}${dateStr ? ` at ${dateStr}` : ''} in ${workspace_path}${author ? ` (author: ${author})` : ''}`,
-                    severity: 'minor',
-                    ts: dateStr ? new Date(dateStr).toISOString() : now.toISOString(),
-                    recall_count: 0,
-                    auto_learned: true,
-                    source: 'brain_from_git',
-                    version: 3,
-                };
-                await redis.set(key, JSON.stringify(lesson));
-                await redis.expire(key, 90 * 86400); // 90-day TTL for git-sourced lessons
-                stored++;
-                if (isFail)
-                    failures++;
-                if (topLessons.length < 5)
-                    topLessons.push(`  ${isFail ? '❌' : '✅'} \`${topic}\` — ${cleanMsg.slice(0, 80)}`);
-            }
-            const lines = [
-                `🧠 **Brain bootstrapped from git history**`,
-                ``,
-                `📊 **Scanned:** ${commitLines.filter(l => l.trim()).length} commits over last ${clampedDays} days`,
-                `✅ **Success lessons stored:** ${stored - failures}`,
-                `❌ **Failure/revert lessons:** ${failures}`,
-                skipped > 0 ? `⏭️  **Already in brain (skipped):** ${skipped}` : '',
-                ``,
-            ];
-            if (topLessons.length > 0) {
-                lines.push(`**Top lessons extracted:**`);
-                lines.push(...topLessons);
-                if (stored > 5)
-                    lines.push(`  …and ${stored - 5} more`);
                 lines.push('');
             }
-            lines.push(`💡 **Next step:** Call \`session_start(focus="...")\` to see these lessons in your briefing.`, `🔄 **Re-run anytime** — duplicates are safely skipped.`);
-            return lines.filter(l => l !== '').join('\n');
+            lines.push(`💡 Outcome confirmed? \`learn_from_attempts(topic="fix:...", outcome="success", ...)\` → improves future predictions`);
+            return lines.join('\n');
         }
         default:
             return null;