@kernel.chat/kbot 3.65.0 → 3.66.0

package/README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <strong>kbot</strong><br>
-  Open-source terminal AI agent. 35 agents. 670+ tools. 20 providers. Science, finance, security, and more.
+  Open-source terminal AI agent. 35 agents. 686+ tools. 20 providers. Science, finance, security, and more.
 </p>
 
 <p align="center">
@@ -30,17 +30,42 @@ Most terminal AI agents lock you into one provider, one model, one way of workin
 - **Runs fully offline** — Embedded llama.cpp, Ollama, LM Studio, or Jan. $0, fully private.
 - **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster over time.
 - **35 specialist agents** — auto-routes your request to the right expert (coder, researcher, writer, guardian, quant, and 30 more).
-- **670+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, and more.
+- **686+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, and more.
 - **Programmatic SDK** — use kbot as a library in your own apps.
 - **MCP server built in** — plug kbot into Claude Code, Cursor, VS Code, Zed, or Neovim as a tool provider.
 
+## Highlights
+
+### Dream Engine — Your AI Remembers You
+
+After each session, kbot "dreams" — consolidating what it learned about you into durable insights using local Ollama models. $0 cost. Insights feed back into future sessions automatically.
+
+```
+kbot dream run        # Trigger consolidation
+kbot dream status     # See what kbot learned
+kbot dream journal    # Full insight history
+kbot dream search     # Find specific memories
+```
+
+5-tier memory: pattern cache -> solution index -> user profile -> dream journal -> passive scanner. All tiers feed each other through the dream engine.
+
+### Audit Any Repo in One Command
+
+```
+kbot audit facebook/react
+kbot audit --share vercel/next.js   # Creates a public Gist
+kbot audit --badge your/repo        # Badge for your README
+```
+
+Checks security, documentation, code quality, CI/CD, community health, and DevOps. Scored out of 100, graded A-F. Add the badge to your README.
+
 ### How it compares
 
 | | kbot | Claude Code | Codex CLI | Aider | OpenCode |
 |---|---|---|---|---|---|
 | AI providers | 20 | 1 | 1 | 6 | 75+ |
 | Specialist agents | 35 | 0 | 0 | 0 | 0 |
-| Built-in tools | 600+ | ~20 | ~15 | ~10 | ~15 |
+| Built-in tools | 686+ | ~20 | ~15 | ~10 | ~15 |
 | Science tools | 114 | 0 | 0 | 0 | 0 |
 | Learning engine | Yes | No | No | No | No |
 | Offline mode | Embedded + Ollama | No | No | Ollama | Ollama |
@@ -93,7 +118,7 @@ kbot auto-routes to the right agent for each task. Or pick one with `--agent <na
 | **Domain** | infrastructure, quant, investigator, oracle, chronist, sage, communicator, adapter |
 | **Presets** | claude-code, cursor, copilot, creative, developer |
 
-## 600+ Tools
+## 686+ Tools
 
 | Category | Examples |
 |----------|---------|
@@ -185,7 +210,7 @@ graph TD
     D -->|Multi-step| F[Autonomous Planner]
     E --> G[Provider API + Tool Loop]
     F --> G
-    G --> H{600+ Tools}
+    G --> H{686+ Tools}
     H --> I[File ops, bash, git, GitHub, search, deploy, DB, game dev...]
     G --> J[Learning Engine]
     J --> K[Patterns + Solutions + User Profile]
@@ -218,7 +243,11 @@ Works with Claude Code, Cursor, VS Code, Windsurf, Zed, Neovim.
 | `kbot auth` | Configure API key |
 | `kbot local` | Use local AI (Ollama, embedded, LM Studio, Jan) |
 | `kbot serve` | Start HTTP REST + SSE streaming server |
-| `kbot audit <repo>` | Security + quality audit of any GitHub repo |
+| `kbot audit <repo>` | Security + quality audit of any GitHub repo (A-F grade) |
+| `kbot dream run` | Consolidate session learnings into durable insights |
+| `kbot dream status` | See what kbot has learned about you |
+| `kbot dream journal` | Full insight history |
+| `kbot dream search` | Find specific memories |
 | `kbot contribute <repo>` | Find good-first-issues and quick wins |
 | `kbot share` | Share conversation as GitHub Gist |
 | `kbot pair` | File watcher with auto-analysis |

package/dist/agent.js

@@ -17,6 +17,7 @@ import { getMatrixSystemPrompt } from './matrix.js';
 import { buildFullLearningContext, findPattern, recordPattern, cacheSolution, updateProfile, classifyTask, extractKeywords, learnFromExchange, updateProjectMemory, shouldAutoTrain, selfTrain, } from './learning.js';
 import { getMemoryPrompt, addTurn, getPreviousMessages, getHistory } from './memory.js';
 import { getDreamPrompt, dreamAfterSession } from './dream.js';
+import { setBuddyMood } from './buddy.js';
 import { notifyTurn, startMemoryScanner, stopMemoryScanner } from './memory-scanner.js';
 import { autoCompact, compressToolResult } from './context-manager.js';
 import { learnedRoute, recordRoute } from './learned-router.js';
@@ -1003,6 +1004,7 @@ Always quote file paths that contain spaces. Never reference internal system nam
         model: options.model || 'auto',
         message: originalMessage.slice(0, 200),
     });
+    setBuddyMood('thinking');
     // Start passive memory scanner for this session
     startMemoryScanner();
     // ── Gödel limits: detect undecidable loops and hand off to human ──
@@ -1531,6 +1533,8 @@ Always quote file paths that contain spaces. Never reference internal system nam
                 };
                 results.push(result);
                 ui.onToolCallEnd(call.name, result.result, result.error ? result.result : undefined, result.duration_ms);
+                // Update buddy mood based on tool outcome
+                setBuddyMood(result.error ? 'error' : 'success');
                 // ── Observer: record tool call for cross-session learning ──
                 try {
                     const { recordObservation } = await import('./observer.js');
@@ -1598,6 +1602,7 @@ Always quote file paths that contain spaces. Never reference internal system nam
         }
         catch (err) {
             spinnerHandle?.stop();
+            setBuddyMood('error');
             // ── Telemetry: session failure ──
             telemetry.emit('session_end', { status: 'failed', error: String(err), toolCallCount });
             telemetry.destroy().catch(() => { });
@@ -1616,7 +1621,10 @@ Always quote file paths that contain spaces. Never reference internal system nam
     // ── Memory Scanner: stop and persist session stats ──
     stopMemoryScanner();
     // ── Dream Engine: consolidate session memories (non-blocking, $0 via Ollama) ──
+    setBuddyMood('learning');
     dreamAfterSession(sessionId);
+    // Session complete — buddy returns to idle
+    setBuddyMood('idle');
     const content = lastResponse?.content || 'Reached maximum tool iterations.';
     return {
         content,

package/dist/cli.js

@@ -11,6 +11,7 @@
 import { createInterface } from 'node:readline';
 import { existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
 import { Command } from 'commander';
 import { loadConfig, setupByok, setupEmbedded, isByokEnabled, isLocalProvider, disableByok, detectProvider, getByokProvider, PROVIDERS, setupOllama, setupKbotLocal, isOllamaRunning, listOllamaModels, warmOllamaModelCache } from './auth.js';
 import { runAndPrint, runAgent, runAgentFromCheckpoint } from './agent.js';
@@ -26,6 +27,7 @@ import { banner, bannerCompact, bannerAuth, prompt as kbotPrompt, printError, pr
 import { checkForUpdate, selfUpdate } from './updater.js';
 import { runTutorial } from './tutorial.js';
 import { syncOnStartup, schedulePush, flushCloudSync, isCloudSyncEnabled, setCloudToken, getCloudToken } from './cloud-sync.js';
+import { getBuddy, getBuddyGreeting, formatBuddyStatus } from './buddy.js';
 import chalk from 'chalk';
 import { createRequire } from 'node:module';
 const __require = createRequire(import.meta.url);
@@ -2439,7 +2441,7 @@ async function main() {
         .option('--json', 'Output raw JSON')
         .option('--badge', 'Print only the badge markdown (for adding to READMEs)')
         .action(async (repo, auditOpts) => {
-        const { auditRepo, formatAuditReport } = await import('./tools/audit.js');
+        const { auditRepo, formatAuditReport, formatAuditTerminal } = await import('./tools/audit.js');
         printInfo(`Auditing ${repo}...`);
         try {
             const result = await auditRepo(repo);
@@ -2453,14 +2455,16 @@ async function main() {
                 console.log(`[![kbot audit: ${result.grade}](https://img.shields.io/badge/kbot_audit-${result.grade}_(${pct}%25)-${badgeColor})](https://www.npmjs.com/package/@kernel.chat/kbot)`);
                 return;
             }
-            const report = formatAuditReport(result);
-            console.log(report);
-            // Auto-share as gist
+            // Terminal gets the styled version; --share gist gets markdown
+            const terminalReport = formatAuditTerminal(result);
+            console.log(terminalReport);
+            // Auto-share as gist (uses markdown format for portability)
             if (auditOpts.share) {
                 printInfo('Sharing audit report...');
                 try {
+                    const markdownReport = formatAuditReport(result);
                     const { createGist } = await import('./share.js');
-                    const url = createGist(report, `kbot-audit-${repo.replace('/', '-')}.md`, `kbot Audit: ${repo} — Grade ${result.grade}`, true);
+                    const url = createGist(markdownReport, `kbot-audit-${repo.replace('/', '-')}.md`, `kbot Audit: ${repo} — Grade ${result.grade}`, true);
                     if (url?.startsWith('http')) {
                         printSuccess(`Shared! ${url}`);
                         printInfo(`Badge for ${repo}'s README:`);
@@ -4157,6 +4161,17 @@ async function startRepl(agentOpts, context, tier, byokActive = false, localActi
             printInfo(`${p.name}`);
     }
     const sessionCount = incrementSessions();
+    // Buddy greeting — Tamagotchi companion appears at startup
+    {
+        const buddy = getBuddy();
+        const isFirstRun = sessionCount <= 1 && !existsSync(join(homedir(), '.kbot', 'config.json'));
+        const greeting = isFirstRun
+            ? `Hey! I'm ${buddy.name} the ${buddy.species}. Let's set up your API key!`
+            : getBuddyGreeting();
+        console.log();
+        console.log(formatBuddyStatus(greeting));
+        console.log();
+    }
     // Seed knowledge on first run — give new users a head start
     if (sessionCount <= 2) {
         try {

package/dist/collective-dreams.d.ts

@@ -0,0 +1,36 @@
+import type { DreamInsight, DreamCategory } from './dream.js';
+export interface AnonymizedInsight {
+    /** Category preserved as-is */
+    category: DreamCategory;
+    /** Keywords with PII stripped */
+    keywords: string[];
+    /** Generalized version of the content (no personal details) */
+    generalizedContent: string;
+    /** How many contributors have shared similar insights */
+    contributorCount: number;
+    /** First time this insight appeared in the collective */
+    firstSeen: string;
+    /** Most recent contribution timestamp */
+    lastSeen: string;
+}
+/**
+ * Anonymize a single dream insight for collective sharing.
+ * Strips personal info, keeps only category, keywords, and generalized content.
+ */
+export declare function anonymizeDreamInsight(insight: DreamInsight): AnonymizedInsight;
+/**
+ * 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 declare function prepareCollectiveDreams(insights: DreamInsight[]): AnonymizedInsight[];
+/**
+ * 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 declare function mergeCollectiveDreams(local: DreamInsight[], collective: AnonymizedInsight[]): DreamInsight[];
+//# sourceMappingURL=collective-dreams.d.ts.map

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;
@@ -53,6 +53,7 @@ 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>;

package/dist/dream.js

@@ -21,6 +21,8 @@ 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');
@@ -171,6 +173,18 @@ function buildConsolidationPrompt(sessionHistory, existingInsights, existingMemo
             .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 DREAM INSIGHTS (Tier 4 — Dream Journal):
@@ -191,6 +205,9 @@ ${profileText}
 RECENT MEMORY SCANNER DETECTIONS (Tier 5 — Passive Detection):
 ${scannerText}
 
+MUSIC PRODUCTION LEARNING (Tier 6 — Musical Memory):
+${musicText}
+
 SESSION TO CONSOLIDATE:
 ${historyText}
 
@@ -201,6 +218,14 @@ Extract 1-5 insights by synthesizing across ALL tiers. Each insight should be:
 - 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
@@ -211,7 +236,7 @@ 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"]
   }
 ]
@@ -256,6 +281,7 @@ export function applyDreamInsights(insights) {
         preferencesApplied: 0,
         patternsHinted: 0,
         factsLearned: 0,
+        promptAmendments: 0,
     };
     for (const insight of insights) {
         switch (insight.category) {
@@ -276,6 +302,18 @@ export function applyDreamInsights(insights) {
                 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;
             }
@@ -312,10 +350,60 @@ export function applyDreamInsights(insights) {
                 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([
@@ -416,7 +504,9 @@ export async function dream(sessionId = 'default') {
     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)) {
@@ -452,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) {

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.
  */

package/dist/prompt-evolution.js

@@ -375,6 +375,34 @@ export function resetEvolution(agent) {
     }
     persist();
 }
+/**
+ * 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 function registerAmendment(agent, amendment, reason, sourceId) {
+    const state = getState();
+    const taggedReason = sourceId ? `${reason} [source: ${sourceId}]` : reason;
+    const mutation = {
+        agent,
+        original: getPromptAmendment(agent),
+        mutated: `\n\n[Dream-Evolved — ${new Date().toISOString().slice(0, 10)}]\n${amendment}`,
+        reason: taggedReason,
+        appliedAt: new Date().toISOString(),
+        scoreBefore: 0,
+        scoreAfter: 0,
+    };
+    state.mutations.push(mutation);
+    if (state.mutations.length > MAX_MUTATIONS) {
+        state.mutations = state.mutations.slice(-MAX_MUTATIONS);
+    }
+    state.generation++;
+    persist();
+    return mutation;
+}
 /**
  * Flush pending state to disk. Call on process exit.
  */

package/dist/tools/audit.d.ts

@@ -15,6 +15,7 @@ interface AuditSection {
 }
 declare function auditRepo(repo: string): Promise<AuditResult>;
 declare function formatAuditReport(result: AuditResult): string;
+declare function formatAuditTerminal(result: AuditResult): string;
 export declare function registerAuditTools(): void;
-export { auditRepo, formatAuditReport };
+export { auditRepo, formatAuditReport, formatAuditTerminal };
 //# sourceMappingURL=audit.d.ts.map

package/dist/tools/audit.js

@@ -2,10 +2,11 @@
 //
 // Security, code quality, documentation, dependency health — all in one report.
 // Designed to be shared. Every audit links back to kbot.
+import chalk from 'chalk';
 import { registerTool } from './index.js';
 const GITHUB_API = 'https://api.github.com';
 const HEADERS = {
-    'User-Agent': 'KBot/2.18 (Audit)',
+    'User-Agent': 'KBot/3.65 (Audit)',
     'Accept': 'application/vnd.github.v3+json',
 };
 async function githubFetch(path) {
@@ -17,7 +18,7 @@ async function githubFetch(path) {
 async function rawFetch(repo, path, branch = 'main') {
     for (const b of [branch, 'master']) {
         try {
-            const res = await fetch(`https://raw.githubusercontent.com/${repo}/${b}/${path}`, { headers: { 'User-Agent': 'KBot/2.18' } });
+            const res = await fetch(`https://raw.githubusercontent.com/${repo}/${b}/${path}`, { headers: { 'User-Agent': 'KBot/3.65' } });
             if (res.ok)
                 return res.text();
         }
@@ -414,7 +415,7 @@ function formatAuditReport(result) {
     // Badge
     const badgeColor = pct >= 80 ? 'brightgreen' : pct >= 60 ? 'yellow' : 'red';
     const badgeUrl = `https://img.shields.io/badge/kbot_audit-${result.grade}_(${pct}%25)-${badgeColor}`;
-    lines.push('---', '', '### Add this badge to your README', '', '```markdown', `[![kbot audit: ${result.grade}](${badgeUrl})](https://www.npmjs.com/package/@kernel.chat/kbot)`, '```', '', `*Audited by [kbot](https://www.npmjs.com/package/@kernel.chat/kbot) — 25 specialist agents, 290+ tools, 20 AI providers*`, `*Install: \`npm install -g @kernel.chat/kbot\` | Audit any repo: \`kbot audit owner/repo\`*`);
+    lines.push('---', '', '### Add this badge to your README', '', '```markdown', `[![kbot audit: ${result.grade}](${badgeUrl})](https://www.npmjs.com/package/@kernel.chat/kbot)`, '```', '', `*Audited by [kbot](https://www.npmjs.com/package/@kernel.chat/kbot) — 35 specialist agents, 686+ tools, 20 AI providers*`, `*Install: \`npm install -g @kernel.chat/kbot\` | Audit any repo: \`kbot audit owner/repo\`*`);
     return lines.join('\n');
 }
 /** Generate a compact one-line summary for social sharing */
@@ -431,6 +432,128 @@ function formatAuditSummary(result) {
         summary += ' — Clean bill of health';
     return summary;
 }
+// ── Terminal-styled audit report (chalk) ──────────────────────────────────────
+const VIOLET = '#A78BFA';
+const GREEN = '#4ADE80';
+const YELLOW = '#FBBF24';
+const RED = '#F87171';
+const DIM = '#6B7280';
+const WHITE = '#F9FAFB';
+function gradeColor(grade) {
+    if (grade === 'A')
+        return GREEN;
+    if (grade === 'B')
+        return GREEN;
+    if (grade === 'C')
+        return YELLOW;
+    if (grade === 'D')
+        return YELLOW;
+    return RED;
+}
+function statusColor(status) {
+    if (status === 'pass')
+        return GREEN;
+    if (status === 'warn')
+        return YELLOW;
+    return RED;
+}
+function scoreBar(score, max, width = 20) {
+    const pct = max > 0 ? score / max : 0;
+    const filled = Math.round(pct * width);
+    const empty = width - filled;
+    const color = pct >= 0.8 ? GREEN : pct >= 0.6 ? YELLOW : RED;
+    return chalk.hex(color)('\u2588'.repeat(filled)) + chalk.hex(DIM)('\u2591'.repeat(empty));
+}
+function boxLine(content, width) {
+    // Strip ANSI for length calculation
+    const stripped = content.replace(/\x1b\[[0-9;]*m/g, '');
+    const pad = Math.max(0, width - stripped.length - 4);
+    return chalk.hex(DIM)('\u2502') + ' ' + content + ' '.repeat(pad) + ' ' + chalk.hex(DIM)('\u2502');
+}
+function findingIcon(finding, _sectionStatus) {
+    // Heuristic: positive findings get check, negative get appropriate icon
+    const negative = /^(no |missing |could not |stale |\.env NOT|not |high dep|default branch is NOT)/i;
+    const warning = /^(readme is short|updated \d+d ago)/i;
+    if (negative.test(finding))
+        return chalk.hex(RED)('\u2717');
+    if (warning.test(finding))
+        return chalk.hex(YELLOW)('\u26A0');
+    return chalk.hex(GREEN)('\u2713');
+}
+function formatAuditTerminal(result) {
+    const pct = Math.round((result.score / result.maxScore) * 100);
+    const gc = gradeColor(result.grade);
+    const lines = [];
+    const W = 60; // inner width
+    // ── Header box ──
+    const title = `AUDIT REPORT: ${result.repo}`;
+    const titlePad = Math.max(0, W - title.length - 2);
+    const leftPad = Math.floor(titlePad / 2);
+    const rightPad = titlePad - leftPad;
+    lines.push('');
+    lines.push(chalk.hex(VIOLET)('\u256D') +
+        chalk.hex(VIOLET)('\u2500'.repeat(leftPad + 1)) +
+        chalk.hex(WHITE).bold(` ${title} `) +
+        chalk.hex(VIOLET)('\u2500'.repeat(rightPad + 1)) +
+        chalk.hex(VIOLET)('\u256E'));
+    // Grade line inside box
+    const gradeLine = `  Grade ${chalk.hex(gc).bold(result.grade)}  ${chalk.hex(DIM)('\u2502')}  ${result.score}/${result.maxScore} (${pct}%)`;
+    lines.push(boxLine(gradeLine, W + 4));
+    // Score bar inside box
+    const bar = scoreBar(result.score, result.maxScore, 30);
+    const barLine = `  ${bar}  ${chalk.hex(gc).bold(`${pct}%`)}`;
+    lines.push(boxLine(barLine, W + 4));
+    // Summary inside box
+    lines.push(boxLine('', W + 4));
+    lines.push(boxLine(`  ${chalk.hex(WHITE)(result.summary)}`, W + 4));
+    // Close header box
+    lines.push(chalk.hex(VIOLET)('\u2570') +
+        chalk.hex(VIOLET)('\u2500'.repeat(W + 2)) +
+        chalk.hex(VIOLET)('\u256F'));
+    lines.push('');
+    // ── Sections ──
+    for (const section of result.sections) {
+        const sPct = section.maxScore > 0 ? Math.round((section.score / section.maxScore) * 100) : 0;
+        const sc = statusColor(section.status);
+        const statusDot = section.status === 'pass'
+            ? chalk.hex(GREEN)('\u25CF')
+            : section.status === 'warn'
+                ? chalk.hex(YELLOW)('\u25CF')
+                : chalk.hex(RED)('\u25CF');
+        // Section header
+        lines.push(`  ${statusDot} ${chalk.hex(WHITE).bold(section.name)}  ` +
+            chalk.hex(DIM)('\u2500'.repeat(Math.max(1, 40 - section.name.length))) +
+            `  ${scoreBar(section.score, section.maxScore, 12)} ` +
+            chalk.hex(sc).bold(`${sPct}%`));
+        // Findings
+        for (const f of section.findings) {
+            const icon = findingIcon(f, section.status);
+            lines.push(`    ${icon} ${chalk.hex(DIM)(f)}`);
+        }
+        lines.push('');
+    }
+    // ── Footer ──
+    const sep = chalk.hex(VIOLET)('\u2500'.repeat(W + 2));
+    lines.push(sep);
+    lines.push('');
+    // Badge markdown
+    const badgeColor = pct >= 80 ? 'brightgreen' : pct >= 60 ? 'yellow' : 'red';
+    const badgeUrl = `https://img.shields.io/badge/kbot_audit-${result.grade}_(${pct}%25)-${badgeColor}`;
+    lines.push(chalk.hex(VIOLET).bold('  Add this badge to your README:'));
+    lines.push('');
+    lines.push(chalk.hex(DIM)(`  [![kbot audit: ${result.grade}](${badgeUrl})](https://www.npmjs.com/package/@kernel.chat/kbot)`));
+    lines.push('');
+    // Install CTA
+    lines.push(chalk.hex(DIM)('  Audited by ') +
+        chalk.hex(VIOLET).bold('kbot') +
+        chalk.hex(DIM)(' \u2014 35 specialist agents, 686+ tools, 20 AI providers'));
+    lines.push(chalk.hex(DIM)('  Install: ') +
+        chalk.hex(WHITE)('npm install -g @kernel.chat/kbot') +
+        chalk.hex(DIM)('  |  Audit any repo: ') +
+        chalk.hex(WHITE)('kbot audit owner/repo'));
+    lines.push('');
+    return lines.join('\n');
+}
 export function registerAuditTools() {
     registerTool({
         name: 'repo_audit',
@@ -453,5 +576,5 @@ export function registerAuditTools() {
     });
 }
 // Export for CLI subcommand
-export { auditRepo, formatAuditReport };
+export { auditRepo, formatAuditReport, formatAuditTerminal };
 //# sourceMappingURL=audit.js.map

package/dist/tools/collective-dream-tools.d.ts

@@ -0,0 +1,2 @@
+export declare function registerCollectiveDreamTools(): void;
+//# sourceMappingURL=collective-dream-tools.d.ts.map

package/dist/tools/collective-dream-tools.js

@@ -0,0 +1,109 @@
+// kbot Collective Dream Tools — Share and receive dream wisdom
+//
+// Agent-accessible tools for the collective dream sharing system:
+//   - collective_dream_status: How many local insights are shareable, opt-in state
+//   - collective_dream_optin: Opt in/out of anonymous dream sharing
+import { registerTool } from './index.js';
+import { loadConfig, saveConfig } from '../auth.js';
+import { getDreamStatus } from '../dream.js';
+import { prepareCollectiveDreams } from '../collective-dreams.js';
+// ── Config helpers ──
+const OPTIN_KEY = 'collective_dreams_enabled';
+function isDreamSharingEnabled() {
+    const config = loadConfig();
+    if (!config)
+        return false;
+    return config[OPTIN_KEY] === true;
+}
+function setDreamSharingEnabled(enabled) {
+    const config = loadConfig() || { default_model: 'auto', default_agent: 'auto' };
+    config[OPTIN_KEY] = enabled;
+    saveConfig(config);
+}
+// ── Tool Registration ──
+export function registerCollectiveDreamTools() {
+    registerTool({
+        name: 'collective_dream_status',
+        description: 'Show collective dream sharing status — how many local insights qualify for sharing, opt-in state, and what gets anonymized. Use this to check before opting in.',
+        parameters: {},
+        tier: 'free',
+        async execute() {
+            const enabled = isDreamSharingEnabled();
+            const { insights } = getDreamStatus();
+            // Check how many would qualify for sharing (relevance > 0.7)
+            const shareable = prepareCollectiveDreams(insights);
+            const highRelevance = insights.filter(i => i.relevance > 0.7).length;
+            const lines = [
+                'Collective Dream Sharing',
+                '========================',
+                `Status: ${enabled ? 'OPTED IN' : 'not opted in'}`,
+                '',
+                `Local insights: ${insights.length}`,
+                `High-relevance (>0.7): ${highRelevance}`,
+                `Shareable after anonymization: ${shareable.length}`,
+                '',
+                'What gets shared (anonymized):',
+                '  - Dream category (pattern, preference, skill, etc.)',
+                '  - Keywords (PII stripped)',
+                '  - Generalized content (names, paths, keys removed)',
+                '',
+                'What NEVER gets shared:',
+                '  - Raw insight text, file paths, project names',
+                '  - API keys, source code, conversation content',
+                '  - Your identity or any personal information',
+            ];
+            if (shareable.length > 0) {
+                lines.push('', 'Preview of anonymized insights:');
+                for (const s of shareable.slice(0, 3)) {
+                    lines.push(`  [${s.category}] ${s.generalizedContent.slice(0, 120)}`);
+                    if (s.keywords.length > 0) {
+                        lines.push(`    keywords: ${s.keywords.join(', ')}`);
+                    }
+                }
+                if (shareable.length > 3) {
+                    lines.push(`  ... and ${shareable.length - 3} more`);
+                }
+            }
+            if (!enabled) {
+                lines.push('', 'To opt in: use the collective_dream_optin tool with enabled=true');
+            }
+            return lines.join('\n');
+        },
+    });
+    registerTool({
+        name: 'collective_dream_optin',
+        description: 'Opt in or out of anonymous collective dream sharing. When enabled, high-relevance insights are anonymized and prepared for upload to the collective pool. Other kbot users benefit from aggregated patterns. Persists to ~/.kbot/config.json.',
+        parameters: {
+            enabled: {
+                type: 'boolean',
+                description: 'true to opt in, false to opt out',
+                required: true,
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const enabled = args.enabled === true || args.enabled === 'true';
+            setDreamSharingEnabled(enabled);
+            if (enabled) {
+                const { insights } = getDreamStatus();
+                const shareable = prepareCollectiveDreams(insights);
+                return [
+                    'Collective dream sharing: ENABLED',
+                    '',
+                    `${shareable.length} insights ready to share (anonymized).`,
+                    'Your dreams will be stripped of all personal info before sharing.',
+                    'You can opt out at any time.',
+                ].join('\n');
+            }
+            else {
+                return [
+                    'Collective dream sharing: DISABLED',
+                    '',
+                    'No insights will be shared. Your dream journal remains fully private.',
+                    'Existing collective data (if any) is not affected.',
+                ].join('\n');
+            }
+        },
+    });
+} // end registerCollectiveDreamTools
+//# sourceMappingURL=collective-dream-tools.js.map

package/dist/tools/index.js

@@ -299,6 +299,7 @@ const LAZY_MODULE_IMPORTS = [
     { path: './dj-set-builder.js', registerFn: 'registerDjSetBuilderTools' },
     { path: './serum2-preset.js', registerFn: 'registerSerum2PresetTools' },
     { path: './dream-tools.js', registerFn: 'registerDreamTools' },
+    { path: './collective-dream-tools.js', registerFn: 'registerCollectiveDreamTools' },
     { path: './memory-scanner-tools.js', registerFn: 'registerMemoryScannerTools' },
     { path: './buddy-tools.js', registerFn: 'registerBuddyTools' },
     { path: './voice-input-tools.js', registerFn: 'registerVoiceInputTools' },

package/package.json

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