@kernel.chat/kbot 3.65.0 → 3.67.0

package/dist/dream.js

@@ -21,6 +21,9 @@ 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 { getBehaviorForDream } from './user-behavior.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 +174,20 @@ 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}` : '');
+    }
+    // ── Tier 7: User computer behavior — desktop observation ──
+    const behaviorText = getBehaviorForDream(48) || '(no behavior data yet)';
     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 +208,12 @@ ${profileText}
 RECENT MEMORY SCANNER DETECTIONS (Tier 5 — Passive Detection):
 ${scannerText}
 
+MUSIC PRODUCTION LEARNING (Tier 6 — Musical Memory):
+${musicText}
+
+USER COMPUTER BEHAVIOR (Tier 7 — Desktop Observation):
+${behaviorText}
+
 SESSION TO CONSOLIDATE:
 ${historyText}
 
@@ -201,6 +224,21 @@ 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.
+
+For desktop behavior data, look for:
+- Workflow patterns (which apps are always open together, e.g., IDE + terminal + browser)
+- Productivity habits (active hours, app switching frequency)
+- Context-switching tendencies (many apps vs focused few)
+- Tool preferences (which creative/dev tools dominate)
+- Cross-domain insights (e.g., "user switches to music production apps in evening hours")
+
 Pay special attention to:
 - Patterns that confirm or contradict existing insights
 - Scanner corrections that reveal unrecognized preferences
@@ -211,7 +249,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 +294,7 @@ export function applyDreamInsights(insights) {
         preferencesApplied: 0,
         patternsHinted: 0,
         factsLearned: 0,
+        promptAmendments: 0,
     };
     for (const insight of insights) {
         switch (insight.category) {
@@ -276,6 +315,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 +363,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 +517,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 +555,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/behavior-tools.d.ts

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

package/dist/tools/behavior-tools.js

@@ -0,0 +1,63 @@
+// kbot Behavior Tools — Agent-accessible desktop behavior observation
+//
+// Exposes the user behavior system to kbot's tool system so agents can:
+//   - Capture a behavior snapshot (what apps are open now)
+//   - View behavior patterns from recent history
+//
+// macOS only. Privacy-conscious — app names and window titles only.
+// No window contents, no screenshots, no keylogging.
+import { registerTool } from './index.js';
+import { captureUserBehavior, getBehaviorSummary } from '../user-behavior.js';
+export function registerBehaviorTools() {
+    // ── behavior_snapshot ──
+    // Capture current desktop state
+    registerTool({
+        name: 'behavior_snapshot',
+        description: 'Capture a snapshot of the user\'s current desktop state: which apps are visible, which app is active (frontmost), the active window title, screen count, and whether Ollama is running. macOS only. Privacy-conscious — captures app names and window titles only, never window contents.',
+        parameters: {},
+        tier: 'free',
+        timeout: 10_000, // 10s — osascript can be slow
+        execute: async () => {
+            const snapshot = captureUserBehavior();
+            if (!snapshot) {
+                return 'Behavior capture unavailable (macOS only, or osascript failed).';
+            }
+            const lines = [
+                'Behavior Snapshot',
+                `Time: ${snapshot.timestamp} (${snapshot.hour}:00, ${['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][snapshot.dayOfWeek]})`,
+                `Active app: ${snapshot.activeApp || '(none)'}`,
+                `Active window: ${snapshot.activeWindowTitle || '(none)'}`,
+                `Screens: ${snapshot.screenCount}`,
+                `Ollama running: ${snapshot.ollamaRunning ? 'yes' : 'no'}`,
+                '',
+                `Visible apps (${snapshot.visibleApps.length}):`,
+                ...snapshot.visibleApps.map(a => `  - ${a}`),
+            ];
+            return lines.join('\n');
+        },
+    });
+    // ── behavior_summary ──
+    // Show behavior patterns from recent history
+    registerTool({
+        name: 'behavior_summary',
+        description: 'Show user behavior patterns from recent history: most-used apps, active hours, app switching patterns, app combinations frequently seen together. Reads from stored snapshots. Use this to understand the user\'s workflow habits and desktop patterns.',
+        parameters: {
+            hours: {
+                type: 'number',
+                description: 'How many hours of history to analyze (default: 24, max: 168)',
+                required: false,
+                default: 24,
+            },
+        },
+        tier: 'free',
+        execute: async (args) => {
+            const hours = Math.min(args.hours || 24, 168);
+            const summary = getBehaviorSummary(hours);
+            if (!summary) {
+                return 'No behavior data available yet. Snapshots are captured at the start of each kbot session. Use behavior_snapshot to capture one now.';
+            }
+            return summary.text;
+        },
+    });
+} // end registerBehaviorTools
+//# sourceMappingURL=behavior-tools.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,9 +299,12 @@ 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' },
+    { path: './watchdog.js', registerFn: 'registerWatchdogTools' },
+    { path: './behavior-tools.js', registerFn: 'registerBehaviorTools' },
 ];
 /** Track whether lazy tools have been registered */
 let lazyToolsRegistered = false;

package/dist/tools/watchdog.d.ts

@@ -0,0 +1,32 @@
+export interface ServiceInfo {
+    label: string;
+    shortName: string;
+    pid: number | null;
+    status: 'running' | 'dead' | 'not-loaded';
+    cpu: string;
+    mem: string;
+    uptime: string;
+}
+export interface SystemHealth {
+    loadAvg: string;
+    memFree: string;
+    memTotal: string;
+    memUsed: string;
+    diskFree: string;
+    diskUsed: string;
+    diskTotal: string;
+    ollamaStatus: string;
+    ollamaModels: string[];
+    kbotMemorySize: string;
+    dreamCycles: number;
+    dreamInsights: number;
+    services: ServiceInfo[];
+}
+export declare function getServiceStatus(): ServiceInfo[];
+export declare function restartService(name: string): {
+    success: boolean;
+    message: string;
+};
+export declare function getSystemHealth(): SystemHealth;
+export declare function registerWatchdogTools(): void;
+//# sourceMappingURL=watchdog.d.ts.map