@kernel.chat/kbot 3.64.0 → 3.65.0

package/dist/cli.js

@@ -3167,20 +3167,28 @@ async function main() {
         .description('Run a dream cycle now (uses local Ollama)')
         .action(async () => {
         const { dream } = await import('./dream.js');
-        printInfo('Dreaming... consolidating session memories with local AI');
+        console.log();
+        console.log(`  ${chalk.hex('#A78BFA')('◆')} ${chalk.bold('Dream Engine')}  ${chalk.dim('consolidating memories...')}`);
+        console.log();
         const result = await dream();
         if (result.success) {
-            printSuccess(`Dream cycle #${result.cycle} complete`);
-            console.log(`  New insights: ${result.newInsights}`);
-            console.log(`  Reinforced: ${result.reinforced}`);
-            console.log(`  Archived: ${result.archived} aged-out`);
-            console.log(`  Duration: ${result.duration}ms`);
+            console.log(`  ${chalk.hex('#4ADE80')('✓')} ${chalk.bold(`Cycle #${result.cycle} complete`)}  ${chalk.dim(`${result.duration}ms`)}`);
+            console.log();
+            console.log(`    ${chalk.hex('#4ADE80')('+')} ${chalk.bold(String(result.newInsights))} new insights`);
+            console.log(`    ${chalk.hex('#A78BFA')('↻')} ${chalk.bold(String(result.reinforced))} reinforced`);
+            if (result.archived > 0) {
+                console.log(`    ${chalk.dim('↓')} ${chalk.dim(`${result.archived} archived (aged out)`)}`);
+            }
+            console.log();
+            console.log(`  ${chalk.dim('View results:')} ${chalk.hex('#A78BFA')('kbot dream status')}`);
         }
         else {
-            printWarn(result.error || 'Dream cycle failed');
-            if (result.archived > 0)
-                console.log(`  (Still archived ${result.archived} aged-out insights)`);
+            console.log(`  ${chalk.hex('#FBBF24')('!')} ${result.error || 'Dream cycle failed'}`);
+            if (result.archived > 0) {
+                console.log(`    ${chalk.dim('↓')} ${chalk.dim(`${result.archived} insights archived (aging only)`)}`);
+            }
         }
+        console.log();
     });
     dreamCmd
         .command('status')
@@ -3188,23 +3196,86 @@ async function main() {
         .action(async () => {
         const { getDreamStatus } = await import('./dream.js');
         const { state, insights, archiveCount } = getDreamStatus();
-        console.log(chalk.bold('\nDream Engine'));
-        console.log(chalk.dim('═══════════════════'));
-        console.log(`Cycles:    ${state.cycles}`);
-        console.log(`Last:      ${state.lastDream || 'never'}`);
-        console.log(`Active:    ${state.activeInsights} insights`);
-        console.log(`Archived:  ${state.totalArchived} (${archiveCount} files)`);
+        // ── Helper functions ──
+        const W = 56; // inner width
+        const box = {
+            tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│',
+            pad: (s, w) => {
+                // Pad string to width, accounting for chalk ANSI codes
+                const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+                const diff = w - visible.length;
+                return diff > 0 ? s + ' '.repeat(diff) : s;
+            },
+        };
+        const relevanceBar = (pct, len = 20) => {
+            const filled = Math.round((pct / 100) * len);
+            const empty = len - filled;
+            const color = pct >= 70 ? chalk.hex('#4ADE80') : pct >= 40 ? chalk.hex('#FBBF24') : chalk.hex('#F87171');
+            return color('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+        };
+        const categoryColor = (cat) => {
+            const colors = {
+                pattern: '#A78BFA', preference: '#67E8F9', skill: '#4ADE80',
+                project: '#FB923C', relationship: '#F472B6',
+            };
+            return chalk.hex(colors[cat] || '#A78BFA');
+        };
+        const categoryChip = (cat) => {
+            const c = categoryColor(cat);
+            return c(` ${cat.toUpperCase()} `);
+        };
+        // ── Header box ──
+        console.log();
+        console.log(chalk.hex('#A78BFA')(`  ${box.tl}${box.h.repeat(W)}${box.tr}`));
+        console.log(chalk.hex('#A78BFA')(`  ${box.v}`) + box.pad(`  ${chalk.hex('#A78BFA').bold('◆ DREAM ENGINE')}  ${chalk.dim('memory consolidation')}`, W) + chalk.hex('#A78BFA')(box.v));
+        console.log(chalk.hex('#A78BFA')(`  ${box.bl}${box.h.repeat(W)}${box.br}`));
+        console.log();
+        // ── Stats row ──
+        const lastDreamDisplay = state.lastDream
+            ? new Date(state.lastDream).toLocaleDateString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })
+            : chalk.dim('never');
+        console.log(`  ${chalk.bold('Cycles')}  ${chalk.hex('#A78BFA')(String(state.cycles))}    ${chalk.bold('Last')}  ${lastDreamDisplay}    ${chalk.bold('Active')}  ${chalk.hex('#4ADE80')(String(state.activeInsights))}`);
+        console.log(`  ${chalk.bold('Total')}   ${chalk.dim(String(state.totalInsights))}    ${chalk.bold('Archived')}  ${chalk.dim(`${state.totalArchived} (${archiveCount} files)`)}`);
+        console.log();
         if (insights.length > 0) {
+            // ── Average relevance bar ──
             const avgRel = Math.round(insights.reduce((s, i) => s + i.relevance, 0) / insights.length * 100);
-            console.log(`Avg relevance: ${avgRel}%`);
-            console.log(chalk.bold('\nTop insights:'));
+            console.log(`  ${chalk.bold('Avg Relevance')}  ${relevanceBar(avgRel, 24)}  ${chalk.bold(`${avgRel}%`)}`);
+            console.log();
+            // ── Category breakdown ──
+            const catCounts = {};
+            for (const i of insights)
+                catCounts[i.category] = (catCounts[i.category] || 0) + 1;
+            const chips = Object.entries(catCounts)
+                .sort((a, b) => b[1] - a[1])
+                .map(([cat, count]) => `${categoryChip(cat)} ${chalk.dim(`${count}`)}`)
+                .join('  ');
+            console.log(`  ${chalk.bold('Categories')}  ${chips}`);
+            console.log();
+            // ── Divider ──
+            console.log(chalk.dim(`  ${'─'.repeat(W)}`));
+            console.log();
+            // ── Top insights ──
+            console.log(`  ${chalk.bold('Top Insights')}`);
+            console.log();
             for (const i of insights.slice(0, 8)) {
                 const pct = Math.round(i.relevance * 100);
-                console.log(`  ${chalk.green(`${pct}%`)} [${chalk.cyan(i.category)}] ${i.content}`);
+                const bar = relevanceBar(pct, 12);
+                const tag = categoryChip(i.category);
+                console.log(`  ${bar} ${chalk.bold(`${pct}%`)}  ${tag}`);
+                console.log(`  ${chalk.white(i.content)}`);
+                if (i.keywords.length > 0) {
+                    console.log(`  ${chalk.dim(i.keywords.map(k => `#${k}`).join('  '))}  ${chalk.dim('·')}  ${chalk.dim(`${i.sessions} sessions`)}`);
+                }
+                console.log();
             }
         }
         else {
-            console.log(chalk.dim('\nNo insights yet. Run: kbot dream run'));
+            console.log(chalk.dim(`  ${'─'.repeat(W)}`));
+            console.log();
+            console.log(`  ${chalk.dim('No insights yet.')}`);
+            console.log(`  ${chalk.dim('Run:')} ${chalk.hex('#A78BFA')('kbot dream run')} ${chalk.dim('to start consolidating memories')}`);
+            console.log();
         }
     });
     dreamCmd
@@ -3213,24 +3284,137 @@ async function main() {
         .action(async (query) => {
         const { searchDreams } = await import('./dream.js');
         const results = searchDreams(query);
+        // Helpers
+        const relevanceBar = (pct, len = 12) => {
+            const filled = Math.round((pct / 100) * len);
+            const empty = len - filled;
+            const color = pct >= 70 ? chalk.hex('#4ADE80') : pct >= 40 ? chalk.hex('#FBBF24') : chalk.hex('#F87171');
+            return color('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+        };
+        const categoryColor = (cat) => {
+            const colors = {
+                pattern: '#A78BFA', preference: '#67E8F9', skill: '#4ADE80',
+                project: '#FB923C', relationship: '#F472B6',
+            };
+            return chalk.hex(colors[cat] || '#A78BFA');
+        };
+        const highlightQuery = (text, q) => {
+            const terms = q.toLowerCase().split(/\s+/);
+            let result = text;
+            for (const term of terms) {
+                const regex = new RegExp(`(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'gi');
+                result = result.replace(regex, chalk.hex('#FBBF24').bold.underline('$1'));
+            }
+            return result;
+        };
         if (results.length === 0) {
-            printInfo(`No insights match "${query}"`);
+            console.log();
+            console.log(`  ${chalk.hex('#A78BFA')('◆')} ${chalk.bold('Dream Search')}  ${chalk.dim(`"${query}"`)}`);
+            console.log();
+            console.log(`  ${chalk.dim('No insights match this query.')}`);
+            console.log(`  ${chalk.dim('Try broader keywords or run')} ${chalk.hex('#A78BFA')('kbot dream run')} ${chalk.dim('first.')}`);
+            console.log();
             return;
         }
-        console.log(chalk.bold(`\n${results.length} insights matching "${query}":\n`));
+        console.log();
+        console.log(`  ${chalk.hex('#A78BFA')('◆')} ${chalk.bold('Dream Search')}  ${chalk.dim(`"${query}"`)}  ${chalk.hex('#4ADE80')(`${results.length} found`)}`);
+        console.log(chalk.dim(`  ${'─'.repeat(52)}`));
+        console.log();
         for (const i of results.slice(0, 15)) {
             const pct = Math.round(i.relevance * 100);
-            console.log(`  ${chalk.green(`${pct}%`)} [${chalk.cyan(i.category)}] ${i.content}`);
-            console.log(chalk.dim(`         ${i.keywords.join(', ')} | ${i.sessions} sessions | ${i.created.split('T')[0]}`));
+            const bar = relevanceBar(pct);
+            const tag = categoryColor(i.category)(` ${i.category.toUpperCase()} `);
+            console.log(`  ${bar} ${chalk.bold(`${pct}%`)}  ${tag}`);
+            console.log(`  ${highlightQuery(i.content, query)}`);
+            const keywordsHighlighted = i.keywords.map(k => highlightQuery(`#${k}`, query)).join('  ');
+            console.log(`  ${keywordsHighlighted}  ${chalk.dim('·')}  ${chalk.dim(`${i.sessions} sessions`)}  ${chalk.dim('·')}  ${chalk.dim(i.created.split('T')[0])}`);
+            console.log();
         }
     });
     dreamCmd
         .command('journal')
         .description('Print the full dream journal')
         .action(async () => {
-        const { getDreamPrompt } = await import('./dream.js');
-        const journal = getDreamPrompt(50);
-        console.log(journal || chalk.dim('Dream journal is empty. Run: kbot dream run'));
+        const { getDreamStatus } = await import('./dream.js');
+        const { state, insights } = getDreamStatus();
+        // Helpers
+        const W = 56;
+        const box = {
+            tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│',
+            pad: (s, w) => {
+                const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+                const diff = w - visible.length;
+                return diff > 0 ? s + ' '.repeat(diff) : s;
+            },
+        };
+        const relevanceBar = (pct, len = 16) => {
+            const filled = Math.round((pct / 100) * len);
+            const empty = len - filled;
+            const color = pct >= 70 ? chalk.hex('#4ADE80') : pct >= 40 ? chalk.hex('#FBBF24') : chalk.hex('#F87171');
+            return color('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+        };
+        const categoryColors = {
+            pattern: '#A78BFA', preference: '#67E8F9', skill: '#4ADE80',
+            project: '#FB923C', relationship: '#F472B6',
+        };
+        const categoryIcon = {
+            pattern: '◇', preference: '♡', skill: '⚡', project: '▸', relationship: '◈',
+        };
+        const categoryColor = (cat) => chalk.hex(categoryColors[cat] || '#A78BFA');
+        if (insights.length === 0) {
+            console.log();
+            console.log(`  ${chalk.hex('#A78BFA')('◆')} ${chalk.bold('Dream Journal')}`);
+            console.log();
+            console.log(`  ${chalk.dim('The journal is empty.')}`);
+            console.log(`  ${chalk.dim('Run')} ${chalk.hex('#A78BFA')('kbot dream run')} ${chalk.dim('after a session to consolidate memories.')}`);
+            console.log();
+            return;
+        }
+        // ── Header ──
+        console.log();
+        console.log(chalk.hex('#A78BFA')(`  ${box.tl}${box.h.repeat(W)}${box.tr}`));
+        const headerContent = `  ${chalk.hex('#A78BFA').bold('◆ DREAM JOURNAL')}  ${chalk.dim(`${insights.length} insights · cycle ${state.cycles}`)}`;
+        console.log(chalk.hex('#A78BFA')(`  ${box.v}`) + box.pad(headerContent, W) + chalk.hex('#A78BFA')(box.v));
+        console.log(chalk.hex('#A78BFA')(`  ${box.bl}${box.h.repeat(W)}${box.br}`));
+        console.log();
+        // ── Group by category ──
+        const grouped = {};
+        for (const i of insights) {
+            if (!grouped[i.category])
+                grouped[i.category] = [];
+            grouped[i.category].push(i);
+        }
+        // Sort categories by total insight count descending
+        const catOrder = Object.entries(grouped).sort((a, b) => b[1].length - a[1].length);
+        for (const [cat, catInsights] of catOrder) {
+            const icon = categoryIcon[cat] || '●';
+            const cc = categoryColor(cat);
+            // ── Category section header ──
+            console.log(`  ${cc(`${icon} ${cat.toUpperCase()}`)}  ${chalk.dim(`(${catInsights.length})`)}`);
+            console.log(`  ${cc('─'.repeat(W))}`);
+            console.log();
+            for (const i of catInsights) {
+                const pct = Math.round(i.relevance * 100);
+                const bar = relevanceBar(pct);
+                const date = i.created.split('T')[0];
+                const reinforced = i.lastReinforced !== i.created
+                    ? chalk.dim(` · reinforced ${i.lastReinforced.split('T')[0]}`)
+                    : '';
+                // Card: relevance bar + content + metadata
+                console.log(`  ${bar} ${chalk.bold(`${pct}%`)}  ${chalk.dim(`${i.sessions} sessions`)}${reinforced}`);
+                console.log(`  ${chalk.white(i.content)}`);
+                if (i.keywords.length > 0) {
+                    console.log(`  ${chalk.dim(i.keywords.map(k => `#${k}`).join('  '))}`);
+                }
+                console.log(`  ${chalk.dim(`${date} · ${i.source} · ${i.id}`)}`);
+                console.log();
+            }
+        }
+        // ── Footer ──
+        console.log(chalk.dim(`  ${'─'.repeat(W)}`));
+        const avgRel = Math.round(insights.reduce((s, i) => s + i.relevance, 0) / insights.length * 100);
+        console.log(`  ${chalk.dim(`${insights.length} active insights · avg relevance ${avgRel}% · ${state.totalArchived} archived`)}`);
+        console.log();
     });
     program.parse(process.argv);
     const opts = program.opts();

package/dist/dream.d.ts

@@ -38,6 +38,22 @@ export declare function ageMemories(insights: DreamInsight[]): {
     aged: DreamInsight[];
     archived: DreamInsight[];
 };
+/**
+ * Apply dream insights back into the learning system.
+ * This is the feedback loop that makes the memory cascade bidirectional:
+ *   - "preference" insights → update user profile via learnFact()
+ *   - "pattern" insights → hint the pattern cache via recordPattern()
+ *   - "skill" insights → record as observed knowledge
+ *   - "project" insights → record as project context
+ *
+ * Called at the end of every dream cycle after new insights are extracted.
+ */
+export declare function applyDreamInsights(insights: DreamInsight[]): ApplyResult;
+export interface ApplyResult {
+    preferencesApplied: number;
+    patternsHinted: number;
+    factsLearned: number;
+}
 /** Run a full dream cycle — consolidate, reinforce, age */
 export declare function dream(sessionId?: string): Promise<DreamResult>;
 export interface DreamResult {
@@ -48,6 +64,8 @@ export interface DreamResult {
     cycle: number;
     duration: number;
     error: string | null;
+    /** Feedback from applying insights back into learning tiers */
+    applied: ApplyResult | null;
 }
 /** Get dream insights for inclusion in system prompt */
 export declare function getDreamPrompt(maxInsights?: number): string;

package/dist/dream.js

@@ -19,6 +19,8 @@ import { join } from 'node:path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
 import { getHistory } from './memory.js';
 import { loadMemory } from './memory.js';
+import { getTopPatterns, getTopSolutions, getProfileSummary, updateProfile, recordPattern, learnFact, } from './learning.js';
+import { getMemoryScannerStats } from './memory-scanner.js';
 // ── Constants ──
 const DREAM_DIR = join(homedir(), '.kbot', 'memory', 'dreams');
 const JOURNAL_FILE = join(DREAM_DIR, 'journal.json');
@@ -149,22 +151,61 @@ function buildConsolidationPrompt(sessionHistory, existingInsights, existingMemo
     const existingText = existingInsights.length > 0
         ? existingInsights.slice(0, 20).map(i => `- [${i.category}] ${i.content}`).join('\n')
         : '(none yet)';
-    return `You are a memory consolidation system. Analyze this conversation session and extract durable insights.
+    // ── Tier 1: Pattern cache — intent → tool sequences ──
+    const topPatterns = getTopPatterns(10);
+    const patternsText = topPatterns.length > 0
+        ? topPatterns.map(p => `- "${p.intent}" → ${p.toolSequence.join(' → ')} (${p.hits}x, ${Math.round(p.successRate * 100)}% success)`).join('\n')
+        : '(no patterns yet)';
+    // ── Tier 2: Solution index — Q&A pairs ──
+    const topSolutions = getTopSolutions(5);
+    const solutionsText = topSolutions.length > 0
+        ? topSolutions.map(s => `- Q: ${s.question.slice(0, 100)} → confidence: ${Math.round(s.confidence * 100)}%, reused ${s.reuses}x`).join('\n')
+        : '(no solutions yet)';
+    // ── Tier 3: User profile ──
+    const profileText = getProfileSummary() || '(no profile data yet)';
+    // ── Tier 5: Memory scanner — recent passive detections ──
+    const scannerStats = getMemoryScannerStats();
+    const scannerText = scannerStats.recentDetections.length > 0
+        ? scannerStats.recentDetections
+            .slice(-5)
+            .map(d => `- [${d.kind}] ${d.content.slice(0, 150)} (confidence: ${Math.round(d.confidence * 100)}%)`)
+            .join('\n')
+        : '(no recent detections)';
+    return `You are a memory consolidation system. Analyze this conversation session and ALL accumulated knowledge tiers to extract durable cross-tier insights.
 
-EXISTING INSIGHTS:
+EXISTING DREAM INSIGHTS (Tier 4 — Dream Journal):
 ${existingText}
 
 EXISTING PERSISTENT MEMORY:
 ${existingMemory.slice(0, 2000) || '(empty)'}
 
+LEARNED PATTERNS (Tier 1 — Pattern Cache):
+${patternsText}
+
+PROVEN SOLUTIONS (Tier 2 — Solution Index):
+${solutionsText}
+
+USER PROFILE (Tier 3):
+${profileText}
+
+RECENT MEMORY SCANNER DETECTIONS (Tier 5 — Passive Detection):
+${scannerText}
+
 SESSION TO CONSOLIDATE:
 ${historyText}
 
 INSTRUCTIONS:
-Extract 1-5 insights from this session. Each insight should be:
+Extract 1-5 insights by synthesizing across ALL tiers. Each insight should be:
 - Durable (useful beyond this session)
 - Non-obvious (not derivable from reading code)
-- About the USER, their preferences, patterns, or project context
+- Cross-tier when possible (e.g., a pattern + preference = workflow insight)
+- About the USER, their preferences, patterns, workflows, or project context
+
+Pay special attention to:
+- Patterns that confirm or contradict existing insights
+- Scanner corrections that reveal unrecognized preferences
+- Solution clusters that suggest emerging expertise areas
+- Profile trends that indicate shifting priorities
 
 Format each insight as a JSON array of objects:
 [
@@ -199,6 +240,133 @@ If none are reinforced, return: []
 
 Respond ONLY with the JSON array.`;
 }
+// ── Memory Cascade: Feed Insights Back into Tiers ──
+/**
+ * Apply dream insights back into the learning system.
+ * This is the feedback loop that makes the memory cascade bidirectional:
+ *   - "preference" insights → update user profile via learnFact()
+ *   - "pattern" insights → hint the pattern cache via recordPattern()
+ *   - "skill" insights → record as observed knowledge
+ *   - "project" insights → record as project context
+ *
+ * Called at the end of every dream cycle after new insights are extracted.
+ */
+export function applyDreamInsights(insights) {
+    const result = {
+        preferencesApplied: 0,
+        patternsHinted: 0,
+        factsLearned: 0,
+    };
+    for (const insight of insights) {
+        switch (insight.category) {
+            case 'preference': {
+                // Feed preference insights back into the knowledge base as observed facts.
+                // This lets the learning context builder surface them in future prompts.
+                learnFact(insight.content, 'preference', 'observed');
+                // Also nudge the user profile if the insight mentions style/tech preferences
+                const lower = insight.content.toLowerCase();
+                if (/\b(?:concise|brief|short)\b/.test(lower)) {
+                    updateProfile({ taskType: 'prefers-concise' });
+                }
+                else if (/\b(?:detailed|thorough|verbose)\b/.test(lower)) {
+                    updateProfile({ taskType: 'prefers-detailed' });
+                }
+                // Extract any tech terms mentioned in the preference
+                const techTerms = extractTechTermsFromInsight(insight.content);
+                if (techTerms.length > 0) {
+                    updateProfile({ techTerms });
+                }
+                result.preferencesApplied++;
+                break;
+            }
+            case 'pattern': {
+                // Feed pattern insights into the knowledge base.
+                // If the insight describes a tool workflow, hint the pattern cache.
+                learnFact(insight.content, 'context', 'observed');
+                // Try to extract a tool sequence from the insight text
+                // (e.g., "User typically reads files then runs tests" → [read_file, run_tests])
+                const toolHints = extractToolHintsFromInsight(insight.content);
+                if (toolHints.length >= 2) {
+                    // Record as a pattern with the insight content as the "intent"
+                    const intentWords = insight.keywords.join(' ') || insight.content.slice(0, 80);
+                    recordPattern(intentWords, toolHints, 0);
+                }
+                result.patternsHinted++;
+                break;
+            }
+            case 'skill': {
+                // Skills are knowledge about what the user is good at or learning.
+                learnFact(insight.content, 'context', 'observed');
+                result.factsLearned++;
+                break;
+            }
+            case 'project': {
+                // Project insights become project-scoped knowledge.
+                learnFact(insight.content, 'project', 'observed');
+                result.factsLearned++;
+                break;
+            }
+            case 'relationship': {
+                // Relationship insights (how user interacts, team dynamics) → context facts.
+                learnFact(insight.content, 'context', 'observed');
+                result.factsLearned++;
+                break;
+            }
+        }
+    }
+    return result;
+}
+/** Extract tech-related terms from insight text */
+function extractTechTermsFromInsight(text) {
+    const techTerms = new Set([
+        'react', 'typescript', 'node', 'python', 'rust', 'go', 'docker',
+        'api', 'database', 'supabase', 'postgres', 'redis', 'mongodb',
+        'css', 'html', 'json', 'sql', 'git', 'npm', 'vite', 'webpack',
+        'tailwind', 'next', 'express', 'fastify', 'deno', 'bun',
+        'playwright', 'vitest', 'jest', 'eslint', 'prettier',
+        'ollama', 'anthropic', 'openai', 'claude', 'gpt',
+        'ableton', 'serum', 'splice', 'osc', 'midi',
+    ]);
+    return text.toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => techTerms.has(w));
+}
+/** Try to extract tool names from insight text describing a workflow */
+function extractToolHintsFromInsight(text) {
+    const toolNames = new Set([
+        'read_file', 'write_file', 'edit_file', 'glob', 'grep', 'bash',
+        'git_status', 'git_diff', 'git_commit', 'git_push', 'git_log',
+        'run_tests', 'test_run', 'build_run', 'type_check', 'lint_check',
+        'web_search', 'url_fetch', 'screenshot', 'browser_navigate',
+        'kbot_agent', 'spawn_agent', 'memory_save', 'memory_search',
+        'research', 'papers_search', 'github_search',
+    ]);
+    // Match tool-like words (snake_case) in the text
+    const words = text.toLowerCase().replace(/[^a-z0-9_\s]/g, ' ').split(/\s+/);
+    const found = words.filter(w => toolNames.has(w));
+    if (found.length >= 2)
+        return found;
+    // Fallback: look for verb patterns that map to common tools
+    const verbMap = [
+        [/\bread(?:s|ing)?\s+(?:file|code|source)/i, 'read_file'],
+        [/\bwrit(?:e|es|ing)\s+(?:file|code)/i, 'write_file'],
+        [/\bedit(?:s|ing)?\b/i, 'edit_file'],
+        [/\bsearch(?:es|ing)?\s+(?:web|online|internet)/i, 'web_search'],
+        [/\brun(?:s|ning)?\s+test/i, 'run_tests'],
+        [/\bgrep(?:s|ping)?\b/i, 'grep'],
+        [/\bgit\s+(?:commit|push|diff|status|log)/i, 'git_commit'],
+        [/\bbuild(?:s|ing)?\b/i, 'build_run'],
+        [/\bbash\b|\bshell\b|\bcommand\b/i, 'bash'],
+    ];
+    const mapped = [];
+    for (const [pattern, tool] of verbMap) {
+        if (pattern.test(text) && !mapped.includes(tool)) {
+            mapped.push(tool);
+        }
+    }
+    return mapped;
+}
 // ── Core Dream Functions ──
 /** Run a full dream cycle — consolidate, reinforce, age */
 export async function dream(sessionId = 'default') {
@@ -210,6 +378,7 @@ export async function dream(sessionId = 'default') {
         cycle: 0,
         duration: 0,
         error: null,
+        applied: null,
     };
     const start = Date.now();
     // Check Ollama availability
@@ -241,9 +410,10 @@ export async function dream(sessionId = 'default') {
     archiveInsights(archived);
     journal = aged;
     result.archived = archived.length;
-    // Phase 2: Extract new insights from session
+    // Phase 2: Extract new insights from session (cross-tier consolidation)
     const consolidationPrompt = buildConsolidationPrompt(history, journal, memory);
     const rawInsights = await ollamaGenerate(consolidationPrompt);
+    const newlyCreatedInsights = [];
     if (rawInsights) {
         try {
             const parsed = JSON.parse(rawInsights);
@@ -255,7 +425,7 @@ export async function dream(sessionId = 'default') {
                         p.content.toLowerCase().includes(j.content.toLowerCase().slice(0, 50)));
                     if (isDupe)
                         continue;
-                    journal.push({
+                    const insight = {
                         id: generateId(),
                         content: p.content,
                         category: p.category || 'pattern',
@@ -265,7 +435,9 @@ export async function dream(sessionId = 'default') {
                         created: now,
                         lastReinforced: now,
                         source: `session_${state.cycles + 1}`,
-                    });
+                    };
+                    journal.push(insight);
+                    newlyCreatedInsights.push(insight);
                     result.newInsights++;
                 }
             }
@@ -306,6 +478,12 @@ export async function dream(sessionId = 'default') {
         journal = journal.slice(0, MAX_INSIGHTS);
         result.archived += overflow.length;
     }
+    // Phase 5: Feed new insights back into learning tiers (memory cascade)
+    // This is the key integration — dream insights don't just sit in the journal,
+    // they propagate back into the pattern cache, solution index, and user profile.
+    if (newlyCreatedInsights.length > 0) {
+        result.applied = applyDreamInsights(newlyCreatedInsights);
+    }
     // Save everything
     saveJournal(journal);
     state.cycles++;

package/dist/learning.d.ts

@@ -179,5 +179,11 @@ export declare function getExtendedStats(): LearningStats & {
     projectsCount: number;
     topKnowledge: string[];
 };
+/** Get the top N patterns from the pattern cache, ranked by effectiveness */
+export declare function getTopPatterns(n?: number): CachedPattern[];
+/** Get the top N solutions from the solution index, ranked by confidence and reuse */
+export declare function getTopSolutions(n?: number): CachedSolution[];
+/** Get a text summary of the user profile for consolidation prompts */
+export declare function getProfileSummary(): string;
 export {};
 //# sourceMappingURL=learning.d.ts.map

package/dist/learning.js

@@ -878,4 +878,45 @@ export function getExtendedStats() {
             .map(k => k.fact.slice(0, 80)),
     };
 }
+// ═══ 12. MEMORY CASCADE ACCESSORS ══════════════════════════════
+// Read-only accessors for the dream engine to pull data from all tiers.
+/** Get the top N patterns from the pattern cache, ranked by effectiveness */
+export function getTopPatterns(n = 10) {
+    return [...patterns]
+        .sort((a, b) => (b.hits * b.successRate) - (a.hits * a.successRate))
+        .slice(0, n);
+}
+/** Get the top N solutions from the solution index, ranked by confidence and reuse */
+export function getTopSolutions(n = 5) {
+    return [...solutions]
+        .sort((a, b) => (b.confidence * (b.reuses + 1)) - (a.confidence * (a.reuses + 1)))
+        .slice(0, n);
+}
+/** Get a text summary of the user profile for consolidation prompts */
+export function getProfileSummary() {
+    const parts = [];
+    if (profile.techStack.length > 0) {
+        parts.push(`Tech stack: ${profile.techStack.join(', ')}`);
+    }
+    if (profile.responseStyle !== 'auto') {
+        parts.push(`Response style: ${profile.responseStyle}`);
+    }
+    const topTasks = Object.entries(profile.taskPatterns)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+    if (topTasks.length > 0) {
+        parts.push(`Task patterns: ${topTasks.map(([t, n]) => `${t}(${n}x)`).join(', ')}`);
+    }
+    const topAgents = Object.entries(profile.preferredAgents)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3);
+    if (topAgents.length > 0) {
+        parts.push(`Preferred agents: ${topAgents.map(([a, n]) => `${a}(${n}x)`).join(', ')}`);
+    }
+    parts.push(`Sessions: ${profile.sessions}, Messages: ${profile.totalMessages}`);
+    if (profile.tokensSaved > 0) {
+        parts.push(`Tokens saved by learning: ${profile.tokensSaved}`);
+    }
+    return parts.join('\n');
+}
 //# sourceMappingURL=learning.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.64.0",
+  "version": "3.65.0",
   "description": "Open-source terminal AI agent. 686+ tools, 35 agents, 20 providers. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {