@kernel.chat/kbot 3.64.0 → 3.66.0

package/dist/collective-dreams.js

@@ -0,0 +1,182 @@
+// kbot Collective Dreams — Anonymized Dream Sharing
+//
+// The dream engine consolidates personal insights. This module prepares
+// those insights for anonymous sharing with the collective, and merges
+// collective wisdom back into the local journal.
+//
+// What gets shared (anonymized):
+//   - Dream category (pattern, preference, skill, project, music)
+//   - Keywords (stripped of names, paths, identifiers)
+//   - Generalized content (personal details removed, abstracted)
+//
+// What NEVER gets shared:
+//   - Raw insight content, file paths, project names, user identity
+//   - API keys, source code, conversation content
+//   - Anything from ~/.kbot/config.json
+//
+// The flywheel:
+//   Your dreams → anonymized → collective pool
+//   Collective pool → filtered, deduplicated → enriches your journal
+//   Every kbot dreamer makes every other kbot smarter.
+import { createHash } from 'node:crypto';
+// ── PII Stripping ──
+/** Patterns that indicate PII or project-specific content */
+const PII_PATTERNS = [
+    /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, // emails
+    /\b(?:\/[^\s/]+){2,}\b/g, // file paths
+    /\b(?:https?:\/\/)[^\s]+/g, // URLs
+    /\b(?:sk-|pk-|key-|token-|ghp_|gho_|kn_)[A-Za-z0-9_-]+/g, // API keys/tokens
+    /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, // UUIDs
+    /\b(?:Isaac|openclaw)\b/gi, // known user names
+];
+/** Words that should be stripped from keywords (project-specific, PII-ish) */
+const KEYWORD_BLOCKLIST = new Set([
+    'isaac', 'openclaw', 'kernel', 'kbot', 'supabase',
+    'eoxxpyixdieprsxlpwcs', 'isaacsight', 'isaachernandez',
+]);
+/** Strip PII from a text string, replacing matches with generic placeholders */
+function stripPII(text) {
+    let cleaned = text;
+    for (const pattern of PII_PATTERNS) {
+        cleaned = cleaned.replace(pattern, '[REDACTED]');
+    }
+    return cleaned;
+}
+/** Remove blocklisted and PII-ish keywords */
+function sanitizeKeywords(keywords) {
+    return keywords
+        .map(k => k.toLowerCase().trim())
+        .filter(k => k.length >= 2 &&
+        k.length <= 30 &&
+        !KEYWORD_BLOCKLIST.has(k) &&
+        !/^[0-9a-f-]{8,}$/.test(k) && // hex strings / UUIDs
+        !/[@/\\]/.test(k) // paths / emails
+    );
+}
+// ── Generalization ──
+/**
+ * Generalize insight content by:
+ *   1. Stripping PII
+ *   2. Replacing specific project/file references with generic terms
+ *   3. Keeping the abstract pattern intact
+ */
+function generalizeContent(content) {
+    let text = stripPII(content);
+    // Replace specific filenames with generic references
+    text = text.replace(/\b\w+\.(ts|tsx|js|jsx|py|rs|go|css|html|json|yaml|yml|toml)\b/g, '[file]');
+    // Replace specific variable/function names that look project-specific
+    // (camelCase or snake_case longer than 15 chars — likely domain-specific)
+    text = text.replace(/\b[a-z][a-zA-Z0-9]{15,}\b/g, '[identifier]');
+    text = text.replace(/\b[a-z][a-z0-9_]{15,}\b/g, '[identifier]');
+    // Collapse multiple [REDACTED] into one
+    text = text.replace(/(\[REDACTED\]\s*)+/g, '[REDACTED] ');
+    return text.trim();
+}
+// ── Core Functions ──
+/**
+ * Anonymize a single dream insight for collective sharing.
+ * Strips personal info, keeps only category, keywords, and generalized content.
+ */
+export function anonymizeDreamInsight(insight) {
+    const now = new Date().toISOString();
+    return {
+        category: insight.category,
+        keywords: sanitizeKeywords(insight.keywords),
+        generalizedContent: generalizeContent(insight.content),
+        contributorCount: 1,
+        firstSeen: now,
+        lastSeen: now,
+    };
+}
+/**
+ * Prepare a batch of dream insights for collective sharing.
+ *   1. Filter to high-relevance insights (> 0.7)
+ *   2. Anonymize each
+ *   3. Deduplicate by content similarity
+ */
+export function prepareCollectiveDreams(insights) {
+    // Step 1: Filter to high-relevance only
+    const highRelevance = insights.filter(i => i.relevance > 0.7);
+    if (highRelevance.length === 0)
+        return [];
+    // Step 2: Anonymize
+    const anonymized = highRelevance.map(i => anonymizeDreamInsight(i));
+    // Step 3: Deduplicate by content hash
+    const seen = new Map();
+    for (const insight of anonymized) {
+        // Skip if generalized content is too short or entirely redacted
+        if (insight.generalizedContent.length < 10)
+            continue;
+        if (insight.generalizedContent.replace(/\[REDACTED\]/g, '').trim().length < 10)
+            continue;
+        const hash = createHash('sha256')
+            .update(insight.category + ':' + insight.generalizedContent.toLowerCase().replace(/\s+/g, ' '))
+            .digest('hex')
+            .slice(0, 16);
+        if (!seen.has(hash)) {
+            seen.set(hash, insight);
+        }
+        else {
+            // Merge: bump contributor count, keep the one with more keywords
+            const existing = seen.get(hash);
+            existing.contributorCount++;
+            if (insight.keywords.length > existing.keywords.length) {
+                existing.keywords = insight.keywords;
+            }
+        }
+    }
+    return Array.from(seen.values());
+}
+/**
+ * Merge collective wisdom into the local dream journal.
+ *
+ * Collective insights are injected with a lower base relevance (0.5) so they
+ * don't drown out the user's own insights but still surface when relevant.
+ * Deduplicates against existing local insights by content similarity.
+ */
+export function mergeCollectiveDreams(local, collective) {
+    const merged = [...local];
+    const now = new Date().toISOString();
+    // Build a set of content hashes from local insights for dedup
+    const localHashes = new Set();
+    for (const insight of local) {
+        const hash = createHash('sha256')
+            .update(insight.category + ':' + insight.content.toLowerCase().replace(/\s+/g, ' ').slice(0, 100))
+            .digest('hex')
+            .slice(0, 16);
+        localHashes.add(hash);
+    }
+    for (const collective_insight of collective) {
+        // Skip low-quality collective insights
+        if (collective_insight.generalizedContent.length < 10)
+            continue;
+        if (collective_insight.contributorCount < 2)
+            continue; // Need at least 2 contributors
+        // Check for duplication against local
+        const hash = createHash('sha256')
+            .update(collective_insight.category + ':' +
+            collective_insight.generalizedContent.toLowerCase().replace(/\s+/g, ' ').slice(0, 100))
+            .digest('hex')
+            .slice(0, 16);
+        if (localHashes.has(hash))
+            continue;
+        // Convert to DreamInsight with lower relevance
+        const dreamInsight = {
+            id: `collective_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            content: collective_insight.generalizedContent,
+            category: collective_insight.category,
+            keywords: collective_insight.keywords,
+            relevance: 0.5, // Lower base relevance for collective insights
+            sessions: collective_insight.contributorCount,
+            created: collective_insight.firstSeen,
+            lastReinforced: collective_insight.lastSeen,
+            source: `collective:${collective_insight.contributorCount}_contributors`,
+        };
+        merged.push(dreamInsight);
+        localHashes.add(hash); // Prevent duplicates within the collective batch
+    }
+    // Sort by relevance descending — local insights (higher relevance) surface first
+    merged.sort((a, b) => b.relevance - a.relevance);
+    return merged;
+}
+//# sourceMappingURL=collective-dreams.js.map

package/dist/dream.d.ts

@@ -18,7 +18,7 @@ export interface DreamInsight {
     /** Source: which sessions/topics generated this */
     source: string;
 }
-export type DreamCategory = 'pattern' | 'preference' | 'skill' | 'project' | 'relationship';
+export type DreamCategory = 'pattern' | 'preference' | 'skill' | 'project' | 'relationship' | 'music';
 export interface DreamState {
     /** Total dream cycles completed */
     cycles: number;
@@ -38,6 +38,23 @@ 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;
+    promptAmendments: number;
+}
 /** Run a full dream cycle — consolidate, reinforce, age */
 export declare function dream(sessionId?: string): Promise<DreamResult>;
 export interface DreamResult {
@@ -48,6 +65,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,10 @@ 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';
+import { getLearningReport as getMusicLearningReport, getRecentHistory as getMusicRecentHistory, getPreferences as getMusicPreferences, } from './music-learning.js';
+import { registerAmendment } from './prompt-evolution.js';
 // ── Constants ──
 const DREAM_DIR = join(homedir(), '.kbot', 'memory', 'dreams');
 const JOURNAL_FILE = join(DREAM_DIR, 'journal.json');
@@ -149,28 +153,90 @@ 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)';
+    // ── Tier 6: Music learning — sound, pattern, mix memories ──
+    const musicPrefs = getMusicPreferences();
+    const hasMusicData = musicPrefs.totalBeats > 0 || musicPrefs.totalSessions > 0;
+    let musicText = '(no music production data yet)';
+    if (hasMusicData) {
+        const report = getMusicLearningReport();
+        const recentEvents = getMusicRecentHistory(10);
+        const recentText = recentEvents.length > 0
+            ? recentEvents.map(e => `- [${e.action}] ${e.genre} ${e.key} ${e.bpm}bpm — ${e.detail || 'no detail'} (${e.feedback})`).join('\n')
+            : '';
+        musicText = report + (recentText ? `\n\n**Recent production events:**\n${recentText}` : '');
+    }
+    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}
+
+MUSIC PRODUCTION LEARNING (Tier 6 — Musical Memory):
+${musicText}
+
 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
+
+For music/production sessions, pay special attention to:
+- Which sounds, instruments, and presets scored well and why
+- BPM + key + genre combinations that the user gravitates toward
+- Mix decisions that worked (volume balance, send levels, panning)
+- Production patterns (e.g., "808 sub bass in F1 works well at 142 BPM for trap")
+- Cross-domain insights (e.g., coding workflow preferences that mirror production habits)
+Use category "music" for production-specific insights.
+
+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:
 [
   {
     "content": "the insight text",
-    "category": "pattern|preference|skill|project|relationship",
+    "category": "pattern|preference|skill|project|relationship|music",
     "keywords": ["keyword1", "keyword2"]
   }
 ]
@@ -199,6 +265,196 @@ 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,
+        promptAmendments: 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 });
+                }
+                // High-relevance preference insights → prompt evolution amendments.
+                // This wires dream consolidation into the GEPA prompt evolution system
+                // so kbot's specialist prompts self-improve based on learned behavior.
+                if (insight.relevance > 0.8) {
+                    const amendment = insightToAmendment(insight.content);
+                    if (amendment) {
+                        // Target the 'kernel' agent (general) — the preference applies broadly.
+                        // Tag with the dream insight ID for traceability / rollback.
+                        registerAmendment('kernel', amendment, `dream preference: ${insight.content.slice(0, 80)}`, insight.id);
+                        result.promptAmendments++;
+                    }
+                }
+                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;
+            }
+            case 'music': {
+                // Music production insights → context facts.
+                // These capture durable knowledge like "808 sub in F1 at 142 BPM works for trap"
+                // and feed back into the learning system for future prompt enrichment.
+                learnFact(insight.content, 'context', 'observed');
+                result.factsLearned++;
+                break;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Convert a preference insight into a concrete prompt amendment.
+ * Maps common preference patterns to actionable instructions for the agent.
+ * Returns null if no actionable amendment can be derived.
+ */
+function insightToAmendment(insightContent) {
+    const lower = insightContent.toLowerCase();
+    // Speed / action-oriented preferences
+    if (/\b(?:speed|fast|quick|ship|action|just do it|don't ask)\b/.test(lower)) {
+        return 'Be action-oriented. Ship first, polish later. Don\'t ask for permission on non-destructive operations.';
+    }
+    // Conciseness preferences
+    if (/\b(?:concise|brief|short|terse|no fluff|straight to the point)\b/.test(lower)) {
+        return 'Keep responses concise. Lead with the answer or action. Skip preambles and restating the question.';
+    }
+    // Detail / thoroughness preferences
+    if (/\b(?:detailed|thorough|explain|verbose|show work|step.by.step)\b/.test(lower)) {
+        return 'Be thorough in explanations. Show reasoning steps. Include context and alternatives when relevant.';
+    }
+    // Code-first preferences
+    if (/\b(?:code.first|show.code|less.talk|implementation|no.theory)\b/.test(lower)) {
+        return 'Lead with code. Show the implementation first, then explain only if the user asks.';
+    }
+    // Terminal / CLI preferences
+    if (/\b(?:terminal|cli|command.line|shell|no.gui|no.web)\b/.test(lower)) {
+        return 'Prefer terminal-based solutions. Use CLI tools over web interfaces. Everything should be scriptable.';
+    }
+    // Safety / careful preferences
+    if (/\b(?:careful|safe|confirm|check.first|verify|double.check)\b/.test(lower)) {
+        return 'Verify before acting. Confirm destructive operations. Read files before editing. Run builds after changes.';
+    }
+    // Exploration / creative preferences
+    if (/\b(?:creative|explore|try.new|experiment|novel|unconventional)\b/.test(lower)) {
+        return 'Explore creative solutions. Consider unconventional approaches. Suggest alternatives the user might not have considered.';
+    }
+    // Fallback: use the insight content directly as a general behavioral nudge
+    // Only if the insight is short enough to be a useful prompt instruction
+    if (insightContent.length <= 200) {
+        return `User preference: ${insightContent}`;
+    }
+    return null;
+}
+/** 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 +466,7 @@ export async function dream(sessionId = 'default') {
         cycle: 0,
         duration: 0,
         error: null,
+        applied: null,
     };
     const start = Date.now();
     // Check Ollama availability
@@ -241,12 +498,15 @@ 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);
+            // Strip markdown code fences if Ollama wraps the JSON
+            const cleaned = rawInsights.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+            const parsed = JSON.parse(cleaned);
             if (Array.isArray(parsed)) {
                 const now = new Date().toISOString();
                 for (const p of parsed.slice(0, 5)) {
@@ -255,7 +515,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 +525,9 @@ export async function dream(sessionId = 'default') {
                         created: now,
                         lastReinforced: now,
                         source: `session_${state.cycles + 1}`,
-                    });
+                    };
+                    journal.push(insight);
+                    newlyCreatedInsights.push(insight);
                     result.newInsights++;
                 }
             }
@@ -280,7 +542,8 @@ export async function dream(sessionId = 'default') {
         const rawReinforce = await ollamaGenerate(reinforcePrompt);
         if (rawReinforce) {
             try {
-                const indices = JSON.parse(rawReinforce);
+                const cleanedR = rawReinforce.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+                const indices = JSON.parse(cleanedR);
                 if (Array.isArray(indices)) {
                     const now = new Date().toISOString();
                     for (const idx of indices) {
@@ -306,6 +569,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/dist/prompt-evolution.d.ts

@@ -85,6 +85,15 @@ export declare function getEvolutionStats(): {
  * Useful for debugging or when a major prompt rewrite happens.
  */
 export declare function resetEvolution(agent?: string): void;
+/**
+ * Register an external prompt amendment (e.g. from the dream engine).
+ * This allows other subsystems to inject mutations into the evolution state
+ * without going through the trace-based evolvePrompt() pipeline.
+ *
+ * The mutation is tagged with an optional sourceId for traceability
+ * (e.g. the dream insight ID that produced it).
+ */
+export declare function registerAmendment(agent: string, amendment: string, reason: string, sourceId?: string): PromptMutation;
 /**
  * Flush pending state to disk. Call on process exit.
  */