@kernel.chat/kbot 3.66.0 → 3.67.0

package/dist/agent.js

@@ -19,6 +19,7 @@ import { getMemoryPrompt, addTurn, getPreviousMessages, getHistory } from './mem
 import { getDreamPrompt, dreamAfterSession } from './dream.js';
 import { setBuddyMood } from './buddy.js';
 import { notifyTurn, startMemoryScanner, stopMemoryScanner } from './memory-scanner.js';
+import { captureUserBehavior } from './user-behavior.js';
 import { autoCompact, compressToolResult } from './context-manager.js';
 import { learnedRoute, recordRoute } from './learned-router.js';
 import { buildCacheablePrompt, createPromptSections } from './prompt-cache.js';
@@ -1007,6 +1008,9 @@ Always quote file paths that contain spaces. Never reference internal system nam
     setBuddyMood('thinking');
     // Start passive memory scanner for this session
     startMemoryScanner();
+    // Capture a behavior snapshot (what apps are open, active window, etc.)
+    // Non-blocking, macOS only, purely local storage
+    captureUserBehavior();
     // ── Gödel limits: detect undecidable loops and hand off to human ──
     const loopDetector = new LoopDetector({
         maxToolRepeats: 5,

package/dist/cli.js

@@ -1005,6 +1005,113 @@ async function main() {
             process.stderr.write(formatMachineProfile(profile));
         }
     });
+    // ── Watchdog — Service & System Status Dashboard ──
+    program
+        .command('watchdog')
+        .alias('wd')
+        .description('Service watchdog — live status of all kbot background services and system health')
+        .option('--json', 'Output as JSON')
+        .option('--restart <service>', 'Restart a specific service (email-agent, discovery, serve, discord, mlx, collective-sync, daemon, kbot-local)')
+        .action(async (opts) => {
+        const { getSystemHealth, getServiceStatus, restartService } = await import('./tools/watchdog.js');
+        // ── Restart mode ──
+        if (opts.restart) {
+            const result = restartService(opts.restart);
+            if (result.success) {
+                console.log();
+                console.log(`  ${chalk.hex('#4ADE80')('✓')} ${result.message}`);
+                console.log();
+            }
+            else {
+                console.log();
+                console.log(`  ${chalk.hex('#F87171')('✗')} ${result.message}`);
+                console.log();
+            }
+            return;
+        }
+        const h = getSystemHealth();
+        // ── JSON mode ──
+        if (opts.json) {
+            console.log(JSON.stringify(h, null, 2));
+            return;
+        }
+        // ── Dashboard rendering ──
+        const ACCENT = chalk.hex('#A78BFA');
+        const GREEN = chalk.hex('#4ADE80');
+        const YELLOW = chalk.hex('#FBBF24');
+        const RED = chalk.hex('#F87171');
+        const DIM = chalk.dim;
+        const running = h.services.filter(s => s.status === 'running').length;
+        const total = h.services.length;
+        const allUp = running === total;
+        // Box drawing
+        const W = 42;
+        const box = {
+            tl: '\u256D', tr: '\u256E', bl: '\u2570', br: '\u256F', h: '\u2500', v: '\u2502',
+            pad: (s, w) => {
+                const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+                const diff = w - visible.length;
+                return diff > 0 ? s + ' '.repeat(diff) : s;
+            },
+        };
+        const row = (content) => {
+            return ACCENT(box.v) + ' ' + box.pad(content, W - 2) + ' ' + ACCENT(box.v);
+        };
+        console.log();
+        console.log('  ' + ACCENT(`${box.tl}${box.h.repeat(W)}${box.tr}`));
+        console.log('  ' + row(`${ACCENT.bold('\u25C6 KBOT SYSTEM STATUS')}`));
+        console.log('  ' + ACCENT(`${box.tl}${box.h.repeat(W)}${box.tr}`.replace(box.tl, '\u251C').replace(box.tr, '\u2524')));
+        // Service count
+        const svcColor = allUp ? GREEN : running > 0 ? YELLOW : RED;
+        console.log('  ' + row(`Services:  ${svcColor(`${running}/${total} running`)}`));
+        // CPU
+        console.log('  ' + row(`CPU Load:  ${chalk.white(h.loadAvg)}`));
+        // RAM
+        console.log('  ' + row(`RAM:       ${chalk.white(h.memUsed)} / ${DIM(h.memTotal)}`));
+        // Disk
+        console.log('  ' + row(`Disk:      ${chalk.white(h.diskFree)} free ${DIM(`/ ${h.diskTotal}`)}`));
+        // Ollama
+        const ollamaColor = h.ollamaStatus === 'online' ? GREEN : RED;
+        const ollamaInfo = h.ollamaModels.length > 0 ? ` ${DIM(`(${h.ollamaModels.length} models)`)}` : '';
+        console.log('  ' + row(`Ollama:    ${ollamaColor(h.ollamaStatus)}${ollamaInfo}`));
+        // Dreams
+        console.log('  ' + row(`Dreams:    ${ACCENT(`${h.dreamCycles}`)} cycles, ${ACCENT(`${h.dreamInsights}`)} insights`));
+        // Memory
+        console.log('  ' + row(`Memory:    ${chalk.white(h.kbotMemorySize)}`));
+        console.log('  ' + ACCENT(`${box.bl}${box.h.repeat(W)}${box.br}`));
+        console.log();
+        // ── Services table ──
+        console.log(`  ${chalk.bold('SERVICES')}`);
+        console.log(`  ${DIM('\u2500'.repeat(64))}`);
+        for (const s of h.services) {
+            const icon = s.status === 'running' ? GREEN('\u2713')
+                : s.status === 'dead' ? RED('\u2717')
+                    : DIM('\u2500');
+            const nameStr = chalk.bold(s.shortName.padEnd(18));
+            const pidStr = s.pid ? DIM(`PID ${String(s.pid).padEnd(8)}`) : DIM('PID -'.padEnd(12));
+            let statusStr;
+            if (s.status === 'running') {
+                statusStr = `CPU ${chalk.white(s.cpu.padEnd(7))} MEM ${chalk.white(s.mem.padEnd(7))} up ${GREEN(s.uptime)}`;
+            }
+            else if (s.status === 'dead') {
+                statusStr = RED('dead — restart with: kbot wd --restart ' + s.shortName);
+            }
+            else {
+                statusStr = DIM('not loaded');
+            }
+            console.log(`  ${icon} ${nameStr} ${pidStr} ${statusStr}`);
+        }
+        console.log();
+        // Ollama model list
+        if (h.ollamaModels.length > 0) {
+            console.log(`  ${chalk.bold('OLLAMA MODELS')}`);
+            console.log(`  ${DIM('\u2500'.repeat(64))}`);
+            for (const m of h.ollamaModels) {
+                console.log(`  ${ACCENT('\u25B8')} ${chalk.white(m)}`);
+            }
+            console.log();
+        }
+    });
     program
         .command('hardware')
         .description('Detect your hardware tier and get personalized model recommendations for local AI')

package/dist/dream.js

@@ -22,6 +22,7 @@ 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');
@@ -185,6 +186,8 @@ function buildConsolidationPrompt(sessionHistory, existingInsights, existingMemo
             : '';
         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):
@@ -208,6 +211,9 @@ ${scannerText}
 MUSIC PRODUCTION LEARNING (Tier 6 — Musical Memory):
 ${musicText}
 
+USER COMPUTER BEHAVIOR (Tier 7 — Desktop Observation):
+${behaviorText}
+
 SESSION TO CONSOLIDATE:
 ${historyText}
 
@@ -226,6 +232,13 @@ For music/production sessions, pay special attention to:
 - 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

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/index.js

@@ -303,6 +303,8 @@ const LAZY_MODULE_IMPORTS = [
     { 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

package/dist/tools/watchdog.js

@@ -0,0 +1,356 @@
+// kbot Watchdog Tools — Service monitoring and system health dashboard
+//
+// Monitors all kbot background services running via launchd on macOS:
+//   - com.kernel.email-agent
+//   - com.kernel.kbot-discovery
+//   - com.kernel.kbot-serve
+//   - com.kernel.discord-bot
+//   - com.kernel.mlx-server
+//   - com.kernel.kbot-collective-sync
+//   - kbot-local MCP
+//   - com.kernel.kbot-daemon (15-min cycle)
+//
+// Tools: service_status, service_restart, system_health
+import { registerTool } from './index.js';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+// ── Known services ──
+const SERVICE_MAP = {
+    'email-agent': 'com.kernel.email-agent',
+    'discovery': 'com.kernel.kbot-discovery',
+    'serve': 'com.kernel.kbot-serve',
+    'discord': 'com.kernel.discord-bot',
+    'mlx': 'com.kernel.mlx-server',
+    'collective-sync': 'com.kernel.kbot-collective-sync',
+    'daemon': 'com.kernel.kbot-daemon',
+    'kbot-local': 'com.kernel.kbot-local',
+};
+// Reverse map: label -> short name
+const LABEL_TO_SHORT = {};
+for (const [short, label] of Object.entries(SERVICE_MAP)) {
+    LABEL_TO_SHORT[label] = short;
+}
+// ── Helpers ──
+function exec(cmd, timeout = 10_000) {
+    try {
+        return execSync(cmd, { timeout, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function getUid() {
+    return exec('id -u');
+}
+function parseServiceLine(line) {
+    // launchctl list output: PID\tStatus\tLabel
+    const match = line.match(/^(-?\d+|-)?\s+(\d+)\s+(.+)$/);
+    if (!match)
+        return null;
+    const pid = match[1] === '-' || !match[1] ? null : parseInt(match[1], 10);
+    const lastExitStatus = parseInt(match[2], 10);
+    const label = match[3].trim();
+    return { pid, lastExitStatus, label };
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getProcessStats(pid) {
+    const raw = exec(`ps -p ${pid} -o %cpu,%mem,etime=`);
+    if (!raw)
+        return { cpu: '?', mem: '?', uptime: '?' };
+    // Output: " 0.1  1.2    01:23:45" or " 0.0  0.3       12:34"
+    const parts = raw.trim().split(/\s+/);
+    if (parts.length >= 3) {
+        return { cpu: `${parts[0]}%`, mem: `${parts[1]}%`, uptime: parts[2] };
+    }
+    return { cpu: '?', mem: '?', uptime: '?' };
+}
+function formatUptime(etime) {
+    // etime can be: "12:34", "01:23:45", "1-01:23:45"
+    if (etime === '?')
+        return etime;
+    const dayMatch = etime.match(/^(\d+)-/);
+    if (dayMatch) {
+        const days = parseInt(dayMatch[1], 10);
+        return `${days}d`;
+    }
+    const parts = etime.split(':');
+    if (parts.length === 3) {
+        const h = parseInt(parts[0], 10);
+        return h > 0 ? `${h}h` : `${parseInt(parts[1], 10)}m`;
+    }
+    if (parts.length === 2) {
+        const m = parseInt(parts[0], 10);
+        return m > 0 ? `${m}m` : `${parseInt(parts[1], 10)}s`;
+    }
+    return etime;
+}
+// ── Core Functions (exported for CLI use) ──
+export function getServiceStatus() {
+    const raw = exec('launchctl list 2>/dev/null');
+    if (!raw)
+        return [];
+    const lines = raw.split('\n');
+    const found = new Map();
+    for (const line of lines) {
+        const parsed = parseServiceLine(line);
+        if (!parsed)
+            continue;
+        // Match against known service labels or grep for kbot/kernel/email
+        if (!parsed.label.match(/kbot|kernel|email/i))
+            continue;
+        const shortName = LABEL_TO_SHORT[parsed.label] || parsed.label.replace(/^com\.kernel\./, '');
+        const alive = parsed.pid !== null && parsed.pid > 0 && isPidAlive(parsed.pid);
+        const stats = alive && parsed.pid ? getProcessStats(parsed.pid) : { cpu: '-', mem: '-', uptime: '-' };
+        found.set(parsed.label, {
+            label: parsed.label,
+            shortName,
+            pid: alive ? parsed.pid : null,
+            status: alive ? 'running' : 'dead',
+            cpu: stats.cpu,
+            mem: stats.mem,
+            uptime: formatUptime(stats.uptime),
+        });
+    }
+    // Add known services that weren't found (not loaded)
+    for (const [short, label] of Object.entries(SERVICE_MAP)) {
+        if (!found.has(label)) {
+            found.set(label, {
+                label,
+                shortName: short,
+                pid: null,
+                status: 'not-loaded',
+                cpu: '-',
+                mem: '-',
+                uptime: '-',
+            });
+        }
+    }
+    // Sort: running first, then dead, then not-loaded
+    const order = { running: 0, dead: 1, 'not-loaded': 2 };
+    return [...found.values()].sort((a, b) => order[a.status] - order[b.status]);
+}
+export function restartService(name) {
+    // Resolve short name to label
+    const label = SERVICE_MAP[name] || name;
+    const uid = getUid();
+    if (!uid) {
+        return { success: false, message: 'Could not determine user ID' };
+    }
+    // Try kickstart first (restarts running services)
+    const domain = `gui/${uid}`;
+    const result = exec(`launchctl kickstart -k ${domain}/${label} 2>&1`, 15_000);
+    if (result.includes('No such process') || result.includes('Could not find service')) {
+        // Try bootstrap (load the plist)
+        const plistPath = join(homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+        if (existsSync(plistPath)) {
+            const loadResult = exec(`launchctl bootstrap ${domain} ${plistPath} 2>&1`, 15_000);
+            if (loadResult.includes('error') || loadResult.includes('Could not')) {
+                return { success: false, message: `Failed to load ${label}: ${loadResult}` };
+            }
+            return { success: true, message: `Loaded and started ${label}` };
+        }
+        return { success: false, message: `Service ${label} not found. Plist missing at ${plistPath}` };
+    }
+    if (result.includes('error') || result.includes('failed')) {
+        return { success: false, message: `Restart failed: ${result}` };
+    }
+    return { success: true, message: `Restarted ${label} via kickstart` };
+}
+export function getSystemHealth() {
+    // ── CPU load ──
+    const loadRaw = exec('sysctl -n vm.loadavg');
+    // Output: "{ 1.23 1.45 1.67 }"
+    const loadAvg = loadRaw.replace(/[{}]/g, '').trim() || '?';
+    // ── Memory ──
+    let memFree = '?';
+    let memTotal = '?';
+    let memUsed = '?';
+    const vmStatRaw = exec('vm_stat');
+    const pageSize = parseInt(exec('sysctl -n hw.pagesize') || '4096', 10);
+    const totalMemBytes = parseInt(exec('sysctl -n hw.memsize') || '0', 10);
+    if (vmStatRaw && totalMemBytes > 0) {
+        const pages = (key) => {
+            const m = vmStatRaw.match(new RegExp(`${key}:\\s+(\\d+)`));
+            return m ? parseInt(m[1], 10) : 0;
+        };
+        const freePages = pages('Pages free') + pages('Pages speculative');
+        const freeBytes = freePages * pageSize;
+        const usedBytes = totalMemBytes - freeBytes;
+        memTotal = `${(totalMemBytes / (1024 ** 3)).toFixed(1)}GB`;
+        memFree = `${(freeBytes / (1024 ** 3)).toFixed(1)}GB`;
+        memUsed = `${(usedBytes / (1024 ** 3)).toFixed(1)}GB`;
+    }
+    // ── Disk ──
+    let diskFree = '?';
+    let diskUsed = '?';
+    let diskTotal = '?';
+    const dfRaw = exec('df -h / 2>/dev/null');
+    if (dfRaw) {
+        const dfLines = dfRaw.split('\n');
+        if (dfLines.length >= 2) {
+            const parts = dfLines[1].split(/\s+/);
+            // Filesystem  Size  Used  Avail  Use%  Mounted
+            if (parts.length >= 4) {
+                diskTotal = parts[1];
+                diskUsed = parts[2];
+                diskFree = parts[3];
+            }
+        }
+    }
+    // ── Ollama ──
+    let ollamaStatus = 'offline';
+    let ollamaModels = [];
+    try {
+        const ollamaRaw = exec('curl -s --connect-timeout 2 http://localhost:11434/api/tags');
+        if (ollamaRaw) {
+            const data = JSON.parse(ollamaRaw);
+            if (data.models) {
+                ollamaStatus = 'online';
+                ollamaModels = data.models.map(m => m.name);
+            }
+        }
+    }
+    catch { /* offline */ }
+    // ── kbot memory ──
+    const kbotMemDir = join(homedir(), '.kbot', 'memory');
+    let kbotMemorySize = '0B';
+    if (existsSync(kbotMemDir)) {
+        const duRaw = exec(`du -sh "${kbotMemDir}" 2>/dev/null`);
+        if (duRaw) {
+            kbotMemorySize = duRaw.split('\t')[0] || '0B';
+        }
+    }
+    // ── Dream state ──
+    let dreamCycles = 0;
+    let dreamInsights = 0;
+    const dreamStateFile = join(homedir(), '.kbot', 'dream', 'state.json');
+    if (existsSync(dreamStateFile)) {
+        try {
+            const state = JSON.parse(readFileSync(dreamStateFile, 'utf-8'));
+            dreamCycles = state.cycles || 0;
+            dreamInsights = state.activeInsights || 0;
+        }
+        catch { /* ignore */ }
+    }
+    // ── Services ──
+    const services = getServiceStatus();
+    return {
+        loadAvg,
+        memFree,
+        memTotal,
+        memUsed,
+        diskFree,
+        diskUsed,
+        diskTotal,
+        ollamaStatus,
+        ollamaModels,
+        kbotMemorySize,
+        dreamCycles,
+        dreamInsights,
+        services,
+    };
+}
+// ── Tool Registration ──
+export function registerWatchdogTools() {
+    // ── service_status ──
+    registerTool({
+        name: 'service_status',
+        description: 'List all kbot background services (launchd) with PID, status, CPU%, MEM%, and uptime. Checks email-agent, discovery daemon, kbot serve, discord bot, MLX server, collective sync, kbot-local MCP, and the main daemon.',
+        parameters: {},
+        tier: 'free',
+        timeout: 15_000,
+        execute: async () => {
+            const services = getServiceStatus();
+            if (services.length === 0) {
+                return 'No kbot services found in launchd. Run `kbot daemon start` to enable background services.';
+            }
+            const running = services.filter(s => s.status === 'running').length;
+            const total = services.length;
+            const lines = [
+                `KBOT SERVICES: ${running}/${total} running`,
+                '',
+                'SERVICE              PID      STATUS       CPU     MEM     UPTIME',
+                '─'.repeat(72),
+            ];
+            for (const s of services) {
+                const icon = s.status === 'running' ? '[OK]' : s.status === 'dead' ? '[!!]' : '[--]';
+                const pid = s.pid ? String(s.pid) : '-';
+                lines.push(`${icon} ${s.shortName.padEnd(18)} ${pid.padEnd(8)} ${s.status.padEnd(12)} ${s.cpu.padEnd(7)} ${s.mem.padEnd(7)} ${s.uptime}`);
+            }
+            return lines.join('\n');
+        },
+    });
+    // ── service_restart ──
+    registerTool({
+        name: 'service_restart',
+        description: 'Restart a kbot background service by name. Use short names: email-agent, discovery, serve, discord, mlx, collective-sync, daemon, kbot-local. Runs launchctl kickstart to restart the service.',
+        parameters: {
+            service: {
+                type: 'string',
+                description: 'Service short name: email-agent, discovery, serve, discord, mlx, collective-sync, daemon, kbot-local',
+                required: true,
+            },
+        },
+        tier: 'free',
+        timeout: 20_000,
+        execute: async (args) => {
+            const name = args.service;
+            if (!name)
+                return 'Error: service name required';
+            // Validate
+            const known = Object.keys(SERVICE_MAP);
+            if (!SERVICE_MAP[name] && !name.startsWith('com.kernel.')) {
+                return `Unknown service "${name}". Known services: ${known.join(', ')}`;
+            }
+            const result = restartService(name);
+            return result.success
+                ? `OK: ${result.message}`
+                : `FAIL: ${result.message}`;
+        },
+    });
+    // ── system_health ──
+    registerTool({
+        name: 'system_health',
+        description: 'Full system health dashboard: CPU load, RAM, disk, Ollama models, kbot memory size, dream journal status, and all service statuses. Compact overview of everything running on this machine.',
+        parameters: {},
+        tier: 'free',
+        timeout: 20_000,
+        execute: async () => {
+            const h = getSystemHealth();
+            const running = h.services.filter(s => s.status === 'running').length;
+            const total = h.services.length;
+            const lines = [
+                'KBOT SYSTEM HEALTH',
+                '═══════════════════',
+                '',
+                `Services:    ${running}/${total} running`,
+                `CPU Load:    ${h.loadAvg}`,
+                `RAM:         ${h.memUsed} used / ${h.memTotal} total (${h.memFree} free)`,
+                `Disk:        ${h.diskUsed} used / ${h.diskTotal} total (${h.diskFree} free)`,
+                `Ollama:      ${h.ollamaStatus}${h.ollamaModels.length > 0 ? ` — ${h.ollamaModels.length} models: ${h.ollamaModels.join(', ')}` : ''}`,
+                `Memory:      ${h.kbotMemorySize}`,
+                `Dreams:      ${h.dreamCycles} cycles, ${h.dreamInsights} active insights`,
+                '',
+                'SERVICES',
+                '─'.repeat(72),
+            ];
+            for (const s of h.services) {
+                const icon = s.status === 'running' ? '[OK]' : s.status === 'dead' ? '[!!]' : '[--]';
+                const pid = s.pid ? String(s.pid) : '-';
+                lines.push(`${icon} ${s.shortName.padEnd(18)} PID ${pid.padEnd(8)} CPU ${s.cpu.padEnd(7)} MEM ${s.mem.padEnd(7)} up ${s.uptime}`);
+            }
+            return lines.join('\n');
+        },
+    });
+}
+//# sourceMappingURL=watchdog.js.map

package/dist/user-behavior.d.ts

@@ -0,0 +1,65 @@
+export interface BehaviorSnapshot {
+    /** ISO timestamp */
+    timestamp: string;
+    /** Hour of day (0-23) */
+    hour: number;
+    /** Day of week (0=Sunday, 6=Saturday) */
+    dayOfWeek: number;
+    /** Visible app names */
+    visibleApps: string[];
+    /** Active (frontmost) app name */
+    activeApp: string | null;
+    /** Active window title */
+    activeWindowTitle: string | null;
+    /** Number of connected screens */
+    screenCount: number;
+    /** Whether Ollama daemon is running */
+    ollamaRunning: boolean;
+}
+export interface BehaviorSummary {
+    /** Number of snapshots analyzed */
+    snapshotCount: number;
+    /** Hours covered */
+    hoursCovered: number;
+    /** Apps ranked by frequency (name → count) */
+    topApps: Array<{
+        app: string;
+        count: number;
+        percent: number;
+    }>;
+    /** Active hours (hour → snapshot count) */
+    activeHours: Record<number, number>;
+    /** App combinations seen together (sorted by frequency) */
+    appCombinations: Array<{
+        apps: string[];
+        count: number;
+    }>;
+    /** Average number of visible apps per snapshot */
+    avgVisibleApps: number;
+    /** Most common active app */
+    mostActiveApp: string | null;
+    /** Ollama usage rate (0-1) */
+    ollamaUsageRate: number;
+    /** Human-readable summary */
+    text: string;
+}
+/**
+ * Capture a behavior snapshot right now.
+ * Runs osascript to detect visible apps, active window, screen count, etc.
+ * Stores the snapshot to ~/.kbot/memory/behavior/ as a timestamped JSON file.
+ *
+ * Non-blocking-safe: catches all errors so it never crashes the caller.
+ * macOS only — returns null on other platforms.
+ */
+export declare function captureUserBehavior(): BehaviorSnapshot | null;
+/**
+ * Read recent snapshots and produce a behavior summary.
+ * @param hours How many hours of history to analyze (default: 24)
+ */
+export declare function getBehaviorSummary(hours?: number): BehaviorSummary | null;
+/**
+ * Get a compact text summary suitable for dream engine injection.
+ * Returns null if no data available.
+ */
+export declare function getBehaviorForDream(hours?: number): string | null;
+//# sourceMappingURL=user-behavior.d.ts.map

package/dist/user-behavior.js

@@ -0,0 +1,301 @@
+// kbot User Behavior — Passive Desktop Observation
+//
+// Captures what the user is doing on their machine: which apps are open,
+// active window, time of day, screen count, whether Ollama is running.
+// Snapshots are stored locally at ~/.kbot/memory/behavior/ as timestamped JSON.
+//
+// Privacy-conscious: captures app names and window titles only.
+// No window contents, no screenshots, no keylogging. macOS only (osascript).
+//
+// Used by the dream engine (Tier 7) to consolidate workflow patterns:
+//   - Most-used apps, active hours, app switching habits
+//   - App combinations (e.g., "Ableton + Chrome often open together")
+//   - Productivity rhythm, context-switching tendencies
+import { execSync } from 'node:child_process';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, } from 'node:fs';
+// ── Constants ──
+const BEHAVIOR_DIR = join(homedir(), '.kbot', 'memory', 'behavior');
+const MAX_SNAPSHOTS = 100;
+// ── Helpers ──
+function ensureDir() {
+    if (!existsSync(BEHAVIOR_DIR))
+        mkdirSync(BEHAVIOR_DIR, { recursive: true });
+}
+function exec(cmd, timeoutMs = 3000) {
+    try {
+        return execSync(cmd, {
+            encoding: 'utf-8',
+            timeout: timeoutMs,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Get list of visible app names via AppleScript (macOS only) */
+function getVisibleApps() {
+    if (platform() !== 'darwin')
+        return [];
+    const raw = exec('osascript -e \'tell application "System Events" to get name of every process whose visible is true\'', 5000);
+    if (!raw)
+        return [];
+    // AppleScript returns comma-separated list
+    return raw.split(',').map(s => s.trim()).filter(Boolean);
+}
+/** Get the frontmost app name */
+function getActiveApp() {
+    if (platform() !== 'darwin')
+        return null;
+    const raw = exec('osascript -e \'tell application "System Events" to get name of first process whose frontmost is true\'');
+    return raw || null;
+}
+/** Get the active window title */
+function getActiveWindowTitle() {
+    if (platform() !== 'darwin')
+        return null;
+    const raw = exec('osascript -e \'tell application "System Events" to get title of front window of (first process whose frontmost is true)\'');
+    // osascript returns empty or error if no window
+    if (!raw || raw.includes('error') || raw.includes('missing value'))
+        return null;
+    return raw;
+}
+/** Get the number of connected screens */
+function getScreenCount() {
+    if (platform() !== 'darwin')
+        return 1;
+    const raw = exec('system_profiler SPDisplaysDataType 2>/dev/null', 5000);
+    if (!raw)
+        return 1;
+    const matches = raw.match(/Resolution:/g);
+    return matches ? matches.length : 1;
+}
+/** Check if Ollama process is running */
+function isOllamaRunning() {
+    const raw = exec('pgrep -x ollama 2>/dev/null || pgrep -f "ollama serve" 2>/dev/null');
+    return raw.length > 0;
+}
+// ── Snapshot Management ──
+function getSnapshotFiles() {
+    ensureDir();
+    return readdirSync(BEHAVIOR_DIR)
+        .filter(f => f.endsWith('.json') && f.startsWith('snap_'))
+        .sort();
+}
+/** Prune old snapshots beyond MAX_SNAPSHOTS (delete oldest) */
+function pruneSnapshots() {
+    const files = getSnapshotFiles();
+    if (files.length <= MAX_SNAPSHOTS)
+        return;
+    const toDelete = files.slice(0, files.length - MAX_SNAPSHOTS);
+    for (const f of toDelete) {
+        try {
+            unlinkSync(join(BEHAVIOR_DIR, f));
+        }
+        catch { /* ignore */ }
+    }
+}
+function loadSnapshot(filename) {
+    try {
+        const raw = readFileSync(join(BEHAVIOR_DIR, filename), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ── Public API ──
+/**
+ * Capture a behavior snapshot right now.
+ * Runs osascript to detect visible apps, active window, screen count, etc.
+ * Stores the snapshot to ~/.kbot/memory/behavior/ as a timestamped JSON file.
+ *
+ * Non-blocking-safe: catches all errors so it never crashes the caller.
+ * macOS only — returns null on other platforms.
+ */
+export function captureUserBehavior() {
+    if (platform() !== 'darwin')
+        return null;
+    try {
+        const now = new Date();
+        const snapshot = {
+            timestamp: now.toISOString(),
+            hour: now.getHours(),
+            dayOfWeek: now.getDay(),
+            visibleApps: getVisibleApps(),
+            activeApp: getActiveApp(),
+            activeWindowTitle: getActiveWindowTitle(),
+            screenCount: getScreenCount(),
+            ollamaRunning: isOllamaRunning(),
+        };
+        ensureDir();
+        const filename = `snap_${now.toISOString().replace(/[:.]/g, '-')}.json`;
+        writeFileSync(join(BEHAVIOR_DIR, filename), JSON.stringify(snapshot, null, 2));
+        // Prune old snapshots
+        pruneSnapshots();
+        return snapshot;
+    }
+    catch {
+        // Non-critical — never crash the caller
+        return null;
+    }
+}
+/**
+ * Read recent snapshots and produce a behavior summary.
+ * @param hours How many hours of history to analyze (default: 24)
+ */
+export function getBehaviorSummary(hours = 24) {
+    try {
+        const files = getSnapshotFiles();
+        if (files.length === 0)
+            return null;
+        const cutoff = Date.now() - hours * 60 * 60 * 1000;
+        const snapshots = [];
+        // Read from newest to oldest, stop when out of range
+        for (let i = files.length - 1; i >= 0; i--) {
+            const snap = loadSnapshot(files[i]);
+            if (!snap)
+                continue;
+            if (new Date(snap.timestamp).getTime() < cutoff)
+                break;
+            snapshots.push(snap);
+        }
+        if (snapshots.length === 0)
+            return null;
+        // ── App frequency ──
+        const appCounts = new Map();
+        for (const snap of snapshots) {
+            for (const app of snap.visibleApps) {
+                appCounts.set(app, (appCounts.get(app) || 0) + 1);
+            }
+        }
+        const topApps = Array.from(appCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 15)
+            .map(([app, count]) => ({
+            app,
+            count,
+            percent: Math.round((count / snapshots.length) * 100),
+        }));
+        // ── Active hours ──
+        const activeHours = {};
+        for (const snap of snapshots) {
+            activeHours[snap.hour] = (activeHours[snap.hour] || 0) + 1;
+        }
+        // ── App combinations (pairs seen together) ──
+        const pairCounts = new Map();
+        for (const snap of snapshots) {
+            const apps = snap.visibleApps.slice().sort();
+            for (let i = 0; i < apps.length; i++) {
+                for (let j = i + 1; j < apps.length; j++) {
+                    const key = `${apps[i]}|${apps[j]}`;
+                    pairCounts.set(key, (pairCounts.get(key) || 0) + 1);
+                }
+            }
+        }
+        const appCombinations = Array.from(pairCounts.entries())
+            .filter(([, count]) => count >= 2) // Only show pairs seen 2+ times
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([key, count]) => ({
+            apps: key.split('|'),
+            count,
+        }));
+        // ── Average visible apps ──
+        const totalVisible = snapshots.reduce((sum, s) => sum + s.visibleApps.length, 0);
+        const avgVisibleApps = Math.round((totalVisible / snapshots.length) * 10) / 10;
+        // ── Most common active app ──
+        const activeCounts = new Map();
+        for (const snap of snapshots) {
+            if (snap.activeApp) {
+                activeCounts.set(snap.activeApp, (activeCounts.get(snap.activeApp) || 0) + 1);
+            }
+        }
+        const mostActiveApp = activeCounts.size > 0
+            ? Array.from(activeCounts.entries()).sort((a, b) => b[1] - a[1])[0][0]
+            : null;
+        // ── Ollama usage ──
+        const ollamaCount = snapshots.filter(s => s.ollamaRunning).length;
+        const ollamaUsageRate = Math.round((ollamaCount / snapshots.length) * 100) / 100;
+        // ── Human-readable text ──
+        const textLines = [];
+        textLines.push(`Behavior summary (${snapshots.length} snapshots over ${hours}h):`);
+        if (topApps.length > 0) {
+            textLines.push(`\nTop apps: ${topApps.slice(0, 8).map(a => `${a.app} (${a.percent}%)`).join(', ')}`);
+        }
+        if (mostActiveApp) {
+            textLines.push(`Most focused app: ${mostActiveApp}`);
+        }
+        // Active hours summary
+        const hourEntries = Object.entries(activeHours)
+            .map(([h, c]) => ({ hour: parseInt(h), count: c }))
+            .sort((a, b) => b.count - a.count);
+        if (hourEntries.length > 0) {
+            const peakHours = hourEntries.slice(0, 3).map(e => `${e.hour}:00`).join(', ');
+            textLines.push(`Peak activity hours: ${peakHours}`);
+        }
+        if (appCombinations.length > 0) {
+            textLines.push(`\nCommon app pairings:`);
+            for (const combo of appCombinations.slice(0, 5)) {
+                textLines.push(`  ${combo.apps.join(' + ')} (${combo.count}x)`);
+            }
+        }
+        textLines.push(`\nAvg visible apps: ${avgVisibleApps}`);
+        textLines.push(`Ollama running: ${Math.round(ollamaUsageRate * 100)}% of the time`);
+        return {
+            snapshotCount: snapshots.length,
+            hoursCovered: hours,
+            topApps,
+            activeHours,
+            appCombinations,
+            avgVisibleApps,
+            mostActiveApp,
+            ollamaUsageRate,
+            text: textLines.join('\n'),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get a compact text summary suitable for dream engine injection.
+ * Returns null if no data available.
+ */
+export function getBehaviorForDream(hours = 48) {
+    const summary = getBehaviorSummary(hours);
+    if (!summary || summary.snapshotCount < 2)
+        return null;
+    const lines = [];
+    // Top apps
+    if (summary.topApps.length > 0) {
+        lines.push(`Top apps by frequency: ${summary.topApps.slice(0, 10).map(a => `${a.app} (${a.percent}%)`).join(', ')}`);
+    }
+    // Most focused
+    if (summary.mostActiveApp) {
+        lines.push(`Most focused (frontmost) app: ${summary.mostActiveApp}`);
+    }
+    // Active hours
+    const hourEntries = Object.entries(summary.activeHours)
+        .map(([h, c]) => ({ hour: parseInt(h), count: c }))
+        .sort((a, b) => b.count - a.count);
+    if (hourEntries.length > 0) {
+        const peakHours = hourEntries.slice(0, 4).map(e => `${e.hour}:00`).join(', ');
+        lines.push(`Peak activity hours: ${peakHours}`);
+    }
+    // App combinations
+    if (summary.appCombinations.length > 0) {
+        const combos = summary.appCombinations.slice(0, 5)
+            .map(c => `${c.apps.join(' + ')} (${c.count}x)`)
+            .join('; ');
+        lines.push(`App combinations: ${combos}`);
+    }
+    // Context
+    lines.push(`Avg visible apps: ${summary.avgVisibleApps}`);
+    lines.push(`Ollama running: ${Math.round(summary.ollamaUsageRate * 100)}% of snapshots`);
+    lines.push(`Based on ${summary.snapshotCount} snapshots over ${summary.hoursCovered}h`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=user-behavior.js.map

package/package.json

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