@kernel.chat/kbot 1.3.1 → 2.3.1

package/dist/cli.js

@@ -10,126 +10,562 @@
 //   $ kbot usage                  # Show usage stats
 import { createInterface } from 'node:readline';
 import { Command } from 'commander';
-import { getApiKey, setupAuth, getUsageStats, loadConfig, verifyApiKey, setupByok, isByokEnabled, disableByok, detectProvider, getByokProvider, PROVIDERS } from './auth.js';
+import { loadConfig, setupByok, isByokEnabled, isLocalProvider, disableByok, detectProvider, getByokProvider, PROVIDERS, setupOllama, setupOpenClaw, isOllamaRunning, listOllamaModels, warmOllamaModelCache } from './auth.js';
 import { runAndPrint, runAgent } from './agent.js';
 import { gatherContext } from './context.js';
 import { registerAllTools } from './tools/index.js';
-import { clearHistory, clearMemory } from './memory.js';
-import { banner, bannerCompact, bannerAuth, matrixConnect, prompt as kbotPrompt, printUsage, printError, printSuccess, printInfo, printResponse, printHelp, printGoodbye, } from './ui.js';
-const VERSION = '1.3.1';
+import { clearHistory, clearMemory, compactHistory, restoreHistory } from './memory.js';
+import { saveSession, loadSession, listSessions, deleteSession, formatSessionList, } from './sessions.js';
+import { createAgent, removeAgent, getAgent, formatAgentList, formatAgentDetail, PRESETS, getMatrixAgentIds, activateMimic, listMimicProfiles, getMimicProfile, } from './matrix.js';
+import { getExtendedStats, incrementSessions, learnFact, selfTrain, getTrainingLog, flushPendingWrites } from './learning.js';
+import { banner, bannerCompact, bannerAuth, prompt as kbotPrompt, printError, printSuccess, printInfo, printResponse, printHelp, printGoodbye, setQuiet, } from './ui.js';
+import { checkForUpdate } from './updater.js';
+import chalk from 'chalk';
+const VERSION = '2.3.1';
 async function main() {
     const program = new Command();
     program
         .name('kbot')
-        .description('K:BOT — Kernel Matrix Terminal Agent')
+        .description('K:BOT — Open-source terminal AI agent. Bring your own key, pick your model, run locally.')
         .version(VERSION)
         .option('-a, --agent <agent>', 'Force a specific agent (kernel, researcher, coder, writer, analyst)')
         .option('-m, --model <model>', 'Override AI model (auto, sonnet, haiku)')
         .option('-s, --stream', 'Stream the response')
-        .option('--computer-use', 'Enable computer use tools (Enterprise only)')
+        .option('-p, --pipe', 'Pipe mode — raw text output for scripting')
+        .option('--json', 'JSON output for scripting')
+        .option('-y, --yes', 'Skip all confirmation prompts')
+        .option('-q, --quiet', 'Minimal output — no banners, spinners, or status')
+        .option('--resume [session]', 'Resume a saved session')
+        .option('--computer-use', 'Enable computer use tools')
+        .option('-t, --thinking', 'Show AI reasoning steps')
+        .option('--thinking-budget <tokens>', 'Thinking token budget (default: 10000)')
+        .option('--safe', 'Confirm destructive operations')
+        .option('--strict', 'Confirm ALL operations')
         .argument('[prompt...]', 'One-shot prompt')
         .helpOption('-h, --help', 'display help for command')
         .addHelpCommand(false)
         .action(() => { });
     // Sub-commands
-    program
-        .command('auth')
-        .description('Configure API key')
+    const ideCmd = program
+        .command('ide')
+        .description('Start IDE protocol server (MCP, ACP)');
+    ideCmd
+        .command('mcp')
+        .description('Start MCP server for VS Code, Cursor, Windsurf, Zed')
+        .action(async () => {
+        const { startMcpServer } = await import('./ide/mcp-server.js');
+        await startMcpServer();
+    });
+    ideCmd
+        .command('acp')
+        .description('Start ACP server for JetBrains IDEs (IntelliJ, WebStorm, PyCharm)')
         .action(async () => {
-        await authFlow();
+        const { startAcpServer } = await import('./ide/acp-server.js');
+        await startAcpServer();
+    });
+    ideCmd
+        .command('status')
+        .description('Show IDE bridge status')
+        .action(async () => {
+        const { initBridge, getStatus } = await import('./ide/bridge.js');
+        await initBridge();
+        const status = getStatus();
+        printInfo('K:BOT IDE Bridge Status');
+        printInfo(`  Version:      ${status.version}`);
+        printInfo(`  Agent:        ${status.agent}`);
+        printInfo(`  Tier:         ${status.tier}`);
+        printInfo(`  Tools:        ${status.toolCount}`);
+        printInfo(`  Patterns:     ${status.learning.patternsCount}`);
+        printInfo(`  Knowledge:    ${status.learning.knowledgeCount}`);
+        printInfo(`  Sessions:     ${status.sessionCount}`);
+        console.log();
+        printInfo('Protocols:');
+        printInfo('  kbot ide mcp    — VS Code, Cursor, Windsurf, Zed, Neovim');
+        printInfo('  kbot ide acp    — IntelliJ, WebStorm, PyCharm, GoLand, Android Studio');
     });
     program
         .command('byok')
-        .description('Bring Your Own Key — use your own LLM API key (Anthropic, OpenAI, or Google)')
-        .option('--off', 'Disable BYOK mode (switch back to Kernel API)')
+        .description('Bring Your Own Key — configure your LLM API key (14 providers)')
+        .option('--off', 'Disable BYOK mode')
+        .action(async (opts) => {
+        if (opts.off) {
+            disableByok();
+            printSuccess('BYOK provider disabled.');
+            return;
+        }
+        await byokFlow();
+    });
+    // Alias: `kbot auth` → same as `kbot byok` (more intuitive name)
+    program
+        .command('auth')
+        .description('Configure your LLM API key (alias for byok)')
+        .option('--off', 'Disable provider')
         .action(async (opts) => {
         if (opts.off) {
             disableByok();
-            printSuccess('BYOK disabled. Using Kernel API key.');
+            printSuccess('Provider disabled.');
             return;
         }
         await byokFlow();
     });
     program
-        .command('usage')
-        .description('Show usage statistics')
+        .command('ollama')
+        .description('Use Ollama for local AI models (no API key needed)')
+        .option('--model <model>', 'Set default Ollama model')
+        .option('--list', 'List available Ollama models')
+        .option('--off', 'Disable Ollama mode')
+        .action(async (opts) => {
+        if (opts.off) {
+            disableByok();
+            printSuccess('Ollama disabled. Provider disabled.');
+            return;
+        }
+        if (opts.list) {
+            const running = await isOllamaRunning();
+            if (!running) {
+                printError('Ollama is not running. Start it with: ollama serve');
+                return;
+            }
+            const models = await listOllamaModels();
+            if (models.length === 0) {
+                printError('No models found. Pull one with: ollama pull llama3.1:8b');
+                return;
+            }
+            printInfo('Available Ollama models:');
+            for (const m of models)
+                printInfo(`  • ${m}`);
+            return;
+        }
+        const running = await isOllamaRunning();
+        if (!running) {
+            printError('Ollama is not running. Start it with: ollama serve');
+            return;
+        }
+        const ok = await setupOllama(opts.model);
+        if (ok) {
+            const models = await listOllamaModels();
+            printSuccess(`Ollama enabled! Using local models (${models.length} available). $0 cost.`);
+            printInfo(`Default model: ${opts.model || PROVIDERS.ollama.defaultModel}`);
+            printInfo('Switch models: kbot ollama --model <name>');
+        }
+        else {
+            printError('Failed to connect to Ollama. Is it running? Try: ollama serve');
+        }
+    });
+    program
+        .command('doctor')
+        .description('Diagnose your kbot setup — check everything is working')
         .action(async () => {
-        const stats = await getUsageStats();
-        if (!stats) {
-            printError('Could not fetch usage. Is your API key valid?');
-            process.exit(1);
+        process.stderr.write('\n');
+        printInfo('K:BOT Doctor — Checking your setup...');
+        process.stderr.write('\n');
+        // 1. Check BYOK provider
+        const config = loadConfig();
+        if (config?.byok_enabled && config?.byok_provider) {
+            const p = PROVIDERS[config.byok_provider];
+            printSuccess(`BYOK provider: ${p?.name || config.byok_provider}`);
+        }
+        // 3. Check Ollama
+        const ollamaUp = await isOllamaRunning();
+        if (ollamaUp) {
+            const models = await listOllamaModels();
+            printSuccess(`Ollama: running (${models.length} models)`);
+            for (const m of models)
+                printInfo(`    ${m}`);
+        }
+        else {
+            printInfo('  Ollama: not running (optional — run: ollama serve)');
+        }
+        // 4. Check OpenClaw
+        try {
+            const res = await fetch('http://127.0.0.1:18789/health', { signal: AbortSignal.timeout(2000) });
+            if (res.ok) {
+                printSuccess('OpenClaw: gateway running at 127.0.0.1:18789');
+            }
+            else {
+                printInfo('  OpenClaw: gateway not responding (optional)');
+            }
+        }
+        catch {
+            printInfo('  OpenClaw: gateway offline (optional — run: openclaw-cmd start)');
+        }
+        // 5. Check Docker (for sandbox tools)
+        try {
+            const { execSync } = await import('node:child_process');
+            execSync('docker info', { timeout: 5000, stdio: 'pipe' });
+            printSuccess('Docker: running (sandbox execution available)');
+        }
+        catch {
+            printInfo('  Docker: not running (optional — needed for sandbox_run)');
+        }
+        // 6. Check git
+        try {
+            const { execSync } = await import('node:child_process');
+            const ver = execSync('git --version', { encoding: 'utf-8', timeout: 3000 }).trim();
+            printSuccess(`Git: ${ver}`);
+        }
+        catch {
+            printError('Git: not found (needed for git tools)');
+        }
+        // 7. Check Node.js version
+        printSuccess(`Node.js: ${process.version}`);
+        // 8. Check config directory
+        const { existsSync } = await import('node:fs');
+        const { homedir } = await import('node:os');
+        const { join } = await import('node:path');
+        const kbotDir = join(homedir(), '.kbot');
+        if (existsSync(kbotDir)) {
+            printSuccess(`Config: ${kbotDir}`);
+        }
+        else {
+            printInfo(`  Config directory will be created at: ${kbotDir}`);
+        }
+        process.stderr.write('\n');
+        // Summary
+        const hasProvider = !!((config?.byok_enabled && config?.byok_provider) || ollamaUp);
+        if (hasProvider) {
+            printSuccess('Ready to go! Run: kbot');
+        }
+        else {
+            printInfo('Get started with one of:');
+            printInfo('  kbot ollama    — Free local AI');
+            printInfo('  kbot byok      — Use your own API key');
+        }
+        process.stderr.write('\n');
+    });
+    program
+        .command('pull')
+        .description('Download recommended Ollama models for local AI')
+        .option('--model <model>', 'Pull a specific model')
+        .action(async (opts) => {
+        const running = await isOllamaRunning();
+        if (!running) {
+            printError('Ollama is not running. Start with: ollama serve');
+            return;
+        }
+        if (opts.model) {
+            printInfo(`Pulling ${opts.model}...`);
+            try {
+                const { execSync } = await import('node:child_process');
+                execSync(`ollama pull ${opts.model}`, { stdio: 'inherit', timeout: 600_000 });
+                printSuccess(`${opts.model} ready!`);
+            }
+            catch {
+                printError(`Failed to pull ${opts.model}`);
+            }
+            return;
+        }
+        const models = await listOllamaModels();
+        const recommended = [
+            { name: 'qwen2.5-coder:7b', desc: 'Best for coding (4.7 GB)', category: 'code' },
+            { name: 'llama3.1:8b', desc: 'General purpose (4.9 GB)', category: 'general' },
+            { name: 'mistral:7b', desc: 'General purpose (4.4 GB)', category: 'general' },
+            { name: 'phi4:14b', desc: 'Reasoning & analysis (8.4 GB)', category: 'reasoning' },
+            { name: 'gemma3:12b', desc: 'Writing & research (8.1 GB)', category: 'general' },
+            { name: 'deepseek-coder-v2:16b', desc: 'Advanced coding (9.7 GB)', category: 'code' },
+            { name: 'codellama:13b', desc: 'Meta code model (7.4 GB)', category: 'code' },
+            { name: 'starcoder2:7b', desc: 'Code completion (4.0 GB)', category: 'code' },
+            { name: 'llama3.2:3b', desc: 'Lightweight fast model (2.0 GB)', category: 'general' },
+            { name: 'codegemma:7b', desc: 'Google code model (5.0 GB)', category: 'code' },
+            { name: 'nemotron-mini', desc: 'NVIDIA Nemotron Mini 4B (2.5 GB)', category: 'general' },
+            { name: 'nemotron-3-nano', desc: 'NVIDIA Nemotron 3 Nano 8B (4.5 GB)', category: 'reasoning' },
+            { name: 'nomic-embed-text', desc: 'Embeddings model (274 MB)', category: 'embeddings' },
+        ];
+        printInfo('Recommended models for kbot:');
+        console.log();
+        for (const rec of recommended) {
+            const installed = models.some(m => m.startsWith(rec.name.split(':')[0]));
+            const icon = installed ? '  ✓' : '  ○';
+            const status = installed ? '(installed)' : '';
+            printInfo(`${icon} ${rec.name.padEnd(25)} ${rec.desc} ${status}`);
+        }
+        console.log();
+        const missing = recommended.filter(r => !models.some(m => m.startsWith(r.name.split(':')[0])));
+        if (missing.length === 0) {
+            printSuccess('All recommended models installed!');
+        }
+        else {
+            printInfo(`Pull missing models: kbot pull --model <name>`);
+            printInfo(`Or pull all: ${missing.map(m => `ollama pull ${m.name}`).join(' && ')}`);
+        }
+    });
+    program
+        .command('openclaw')
+        .description('Use OpenClaw gateway as AI provider')
+        .option('--token <token>', 'Gateway auth token')
+        .option('--off', 'Disable OpenClaw mode')
+        .action(async (opts) => {
+        if (opts.off) {
+            disableByok();
+            printSuccess('OpenClaw disabled. Provider disabled.');
+            return;
+        }
+        const ok = await setupOpenClaw(opts.token);
+        if (ok) {
+            printSuccess('OpenClaw enabled! Connected to local gateway at 127.0.0.1:18789.');
+        }
+        else {
+            printError('Cannot connect to OpenClaw gateway. Start it first.');
         }
-        printUsage(stats);
     });
     program.parse(process.argv);
     const opts = program.opts();
     const promptArgs = program.args;
+    // Quiet mode: suppress banners, spinners, status messages
+    if (opts.quiet)
+        setQuiet(true);
     // If a sub-command was run, we're done
-    if (['auth', 'usage', 'byok'].includes(program.args[0]))
-        return;
-    // Check for API key (Kernel or BYOK)
-    const byokActive = isByokEnabled();
-    const apiKey = getApiKey();
-    if (!apiKey && !byokActive) {
-        console.log(banner());
-        printInfo('No API key found. Let\'s connect you to the Matrix.');
-        printInfo('Or run `kbot byok` to use your own Anthropic API key.');
-        console.log();
-        await authFlow();
+    if (['byok', 'auth', 'ide', 'ollama', 'openclaw', 'pull', 'doctor'].includes(program.args[0]))
         return;
+    // Check for API key (BYOK or local provider)
+    let byokActive = isByokEnabled();
+    let localActive = byokActive && isLocalProvider(getByokProvider());
+    // AUTO-SETUP: If no provider configured, try to auto-detect and configure one
+    if (!byokActive) {
+        // Priority 1: Check environment variables (instant, no network)
+        const envDetected = autoDetectFromEnv();
+        if (envDetected) {
+            byokActive = true;
+            localActive = isLocalProvider(envDetected);
+            printSuccess(`Auto-detected ${PROVIDERS[envDetected].name} from environment.`);
+        }
+        // Priority 2: Check local providers in PARALLEL (both at once, use whichever responds first)
+        if (!byokActive) {
+            const [ollamaResult, openclawResult] = await Promise.allSettled([
+                // Check Ollama
+                (async () => {
+                    const up = await isOllamaRunning();
+                    if (!up)
+                        return null;
+                    const models = await listOllamaModels();
+                    if (models.length === 0)
+                        return null;
+                    const ok = await setupOllama();
+                    return ok ? { provider: 'ollama', models: models.length } : null;
+                })(),
+                // Check OpenClaw
+                (async () => {
+                    try {
+                        const res = await fetch('http://127.0.0.1:18789/health', { signal: AbortSignal.timeout(1500) });
+                        if (!res.ok)
+                            return null;
+                        const ok = await setupOpenClaw();
+                        return ok ? { provider: 'openclaw' } : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                })(),
+            ]);
+            // Prefer Ollama if both available (more models, more control)
+            const ollamaOk = ollamaResult.status === 'fulfilled' && ollamaResult.value;
+            const openclawOk = openclawResult.status === 'fulfilled' && openclawResult.value;
+            if (ollamaOk) {
+                byokActive = true;
+                localActive = true;
+                printSuccess(`Auto-configured Ollama (${ollamaOk.models} models). Ready — $0 cost!`);
+            }
+            else if (openclawOk) {
+                byokActive = true;
+                localActive = true;
+                printSuccess('Auto-configured OpenClaw gateway. Ready — $0 cost!');
+            }
+        }
+        // Still no provider — launch guided setup for new users
+        if (!byokActive) {
+            const result = await guidedSetup();
+            if (!result)
+                return;
+            byokActive = true;
+            localActive = result.local;
+        }
+    }
+    /** Auto-detect provider from environment variables */
+    function autoDetectFromEnv() {
+        const envKeys = [
+            { env: 'ANTHROPIC_API_KEY', provider: 'anthropic' },
+            { env: 'OPENAI_API_KEY', provider: 'openai' },
+            { env: 'GOOGLE_API_KEY', provider: 'google' },
+            { env: 'MISTRAL_API_KEY', provider: 'mistral' },
+            { env: 'XAI_API_KEY', provider: 'xai' },
+            { env: 'DEEPSEEK_API_KEY', provider: 'deepseek' },
+            { env: 'GROQ_API_KEY', provider: 'groq' },
+            { env: 'TOGETHER_API_KEY', provider: 'together' },
+            { env: 'FIREWORKS_API_KEY', provider: 'fireworks' },
+            { env: 'PERPLEXITY_API_KEY', provider: 'perplexity' },
+            { env: 'COHERE_API_KEY', provider: 'cohere' },
+            { env: 'NVIDIA_API_KEY', provider: 'nvidia' },
+        ];
+        for (const { env, provider } of envKeys) {
+            if (process.env[env])
+                return provider;
+        }
+        return null;
     }
-    // Register tools
-    await registerAllTools();
-    // Gather project context (once at startup)
-    const context = gatherContext();
+    // Permission mode: autonomous by default, users opt-in to confirmations
+    {
+        const { setPermissionMode } = await import('./permissions.js');
+        if (opts.yes) {
+            // --yes / -y: skip all confirmations (for scripts & CI)
+            setPermissionMode('permissive');
+        }
+        else if (opts.strict) {
+            setPermissionMode('strict');
+        }
+        else if (opts.safe || process.env.KBOT_SAFE) {
+            setPermissionMode('normal');
+        }
+        else {
+            // DEFAULT: permissive — kbot acts autonomously, no confirmation prompts
+            setPermissionMode('permissive');
+        }
+    }
+    // Parallel startup: register tools, gather context, and check updates simultaneously
+    const [, context] = await Promise.all([
+        registerAllTools({ computerUse: opts.computerUse }),
+        Promise.resolve(gatherContext()),
+        // Non-blocking update check — fire and forget
+        Promise.resolve().then(() => {
+            try {
+                const msg = checkForUpdate(VERSION);
+                if (msg)
+                    printSuccess(msg);
+            }
+            catch { /* non-critical */ }
+        }),
+    ]);
     const config = loadConfig();
-    const tier = byokActive ? 'growth' : (config?.tier || 'free');
+    const tier = 'free';
     const agentOpts = {
         agent: opts.agent || 'auto',
         model: opts.model,
-        stream: opts.stream,
+        stream: opts.stream ?? true, // Stream by default for faster perceived response
         context,
         tier,
+        thinking: opts.thinking || false,
+        thinkingBudget: opts.thinkingBudget ? (parseInt(opts.thinkingBudget, 10) || 10000) : undefined,
     };
-    // One-shot mode: kbot "fix the bug"
-    if (promptArgs.length > 0 && !['auth', 'usage', 'byok'].includes(promptArgs[0])) {
-        console.log(bannerCompact());
-        const message = promptArgs.join(' ');
-        await runAndPrint(message, agentOpts);
+    // Pipe mode: echo "prompt" | kbot -p  OR  kbot -p "prompt"
+    if (opts.pipe) {
+        let message = promptArgs.join(' ');
+        if (!message && !process.stdin.isTTY) {
+            // Read from stdin pipe
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(chunk);
+            message = Buffer.concat(chunks).toString('utf-8').trim();
+        }
+        if (!message) {
+            process.stderr.write('Error: no prompt provided\n');
+            process.exit(1);
+        }
+        try {
+            const response = await runAgent(message, agentOpts);
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({
+                    content: response.content,
+                    agent: response.agent,
+                    model: response.model,
+                    toolCalls: response.toolCalls,
+                    usage: response.usage,
+                }) + '\n');
+            }
+            else {
+                process.stdout.write(response.content + '\n');
+            }
+        }
+        catch (err) {
+            process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
         return;
     }
-    // Interactive REPL mode
-    await startRepl(agentOpts, context, tier);
-}
-async function authFlow() {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    console.log(bannerAuth());
-    printInfo('Enter your API key (get one at kernel.chat/#/api-docs):');
-    console.log();
-    const key = await new Promise((resolve) => {
-        rl.question('  kn_live_', (answer) => {
-            resolve('kn_live_' + answer.trim());
-            rl.close();
-        });
-    });
-    if (!key.startsWith('kn_live_') || key.length < 12) {
-        printError('Invalid key format. Keys start with kn_live_');
-        process.exit(1);
+    // Resume session if --resume flag is used
+    if (opts.resume) {
+        const sessionId = typeof opts.resume === 'string' ? opts.resume : undefined;
+        if (sessionId) {
+            const session = loadSession(sessionId);
+            if (session) {
+                restoreHistory(session.history);
+                if (session.agent)
+                    agentOpts.agent = session.agent;
+                printSuccess(`Resumed session: ${session.name} (${session.turnCount} turns)`);
+            }
+            else {
+                printError(`Session not found: ${sessionId}`);
+                printInfo('Run /sessions to list saved sessions.');
+            }
+        }
+        else {
+            // Resume most recent session
+            const { getLastSession } = await import('./sessions.js');
+            const last = getLastSession();
+            if (last) {
+                restoreHistory(last.history);
+                if (last.agent)
+                    agentOpts.agent = last.agent;
+                printSuccess(`Resumed last session: ${last.name}`);
+            }
+            else {
+                printInfo('No previous sessions found.');
+            }
+        }
     }
-    printInfo('Connecting to Kernel Matrix...');
-    const result = await verifyApiKey(key);
-    if (!result.valid) {
-        printError(`Connection failed: ${result.error}`);
-        process.exit(1);
+    // Stdin pipe composability: cat file.txt | kbot "explain this"
+    // Read stdin BEFORE one-shot check, so it's available for both paths
+    let stdinContent = '';
+    if (!process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(chunk);
+        stdinContent = Buffer.concat(chunks).toString('utf-8').trim();
     }
-    const ok = await setupAuth(key);
-    if (!ok) {
-        printError('Key verification failed. Check your key and try again.');
-        process.exit(1);
+    // One-shot mode: kbot "fix the bug" — always stream for speed
+    if (promptArgs.length > 0 && !['byok', 'auth', 'ide', 'ollama', 'openclaw', 'pull', 'doctor'].includes(promptArgs[0])) {
+        if (!opts.pipe)
+            console.log(bannerCompact());
+        let message = promptArgs.join(' ');
+        // If stdin was piped in, prepend it as context
+        if (stdinContent) {
+            message = `${stdinContent}\n\n---\n${message}`;
+        }
+        // JSON output mode — structured output for scripting
+        if (opts.json) {
+            agentOpts.stream = false; // No streaming for JSON mode
+            const response = await runAgent(message, agentOpts);
+            process.stdout.write(JSON.stringify({
+                content: response.content,
+                agent: response.agent,
+                model: response.model,
+                toolCalls: response.toolCalls,
+                usage: response.usage,
+            }) + '\n');
+            return;
+        }
+        agentOpts.stream = true; // Force streaming for faster one-shot
+        await runAndPrint(message, agentOpts);
+        return;
     }
-    console.log();
-    console.log(matrixConnect(result.tier || 'free', result.agents?.length || 5));
-    printSuccess('Ready. Run `kbot` to start.');
+    // Stdin-only mode: echo "what is 2+2" | kbot (no prompt args, just piped input)
+    if (stdinContent && promptArgs.length === 0) {
+        if (opts.json) {
+            agentOpts.stream = false;
+            const response = await runAgent(stdinContent, agentOpts);
+            process.stdout.write(JSON.stringify({
+                content: response.content,
+                agent: response.agent,
+                model: response.model,
+                toolCalls: response.toolCalls,
+                usage: response.usage,
+            }) + '\n');
+            return;
+        }
+        agentOpts.stream = true;
+        await runAndPrint(stdinContent, agentOpts);
+        return;
+    }
+    // Interactive REPL mode
+    await startRepl(agentOpts, context, tier, byokActive, localActive);
 }
 async function byokFlow() {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -138,11 +574,12 @@ async function byokFlow() {
     printInfo('Use your own LLM API key. You pay the provider directly for tokens.');
     printInfo('Kernel routing + tools + collective intelligence are free.');
     console.log();
-    printInfo('Supported providers (12):');
+    printInfo('Supported providers (14):');
     printInfo('  Anthropic (Claude)    OpenAI (GPT)       Google (Gemini)');
     printInfo('  Mistral AI            xAI (Grok)         DeepSeek');
     printInfo('  Groq                  Together AI        Fireworks AI');
     printInfo('  Perplexity            Cohere             NVIDIA NIM');
+    printInfo('  Ollama (local, free)  OpenClaw (local gateway)');
     console.log();
     printInfo('Paste your API key (auto-detected by prefix):');
     console.log();
@@ -196,81 +633,338 @@ async function byokFlow() {
     }
     console.log();
     printSuccess(`BYOK mode enabled — ${providerConfig.name}`);
-    printInfo('You pay the provider directly. No message limits.');
-    printInfo('Kernel routing + 17 agents + tools = free.');
+    printInfo('You pay the provider directly. No message limits. No restrictions.');
+    printInfo('All 81 tools + 17 agents + learning system = yours.');
     console.log();
     printSuccess('Ready. Run `kbot` to start.');
 }
-async function startRepl(agentOpts, context, tier) {
-    console.log(banner());
-    // Show connection info
-    const byok = isByokEnabled();
-    const agentCount = byok || tier === 'growth' || tier === 'enterprise' ? 17 : 5;
-    if (byok) {
-        const provider = getByokProvider();
-        const providerConfig = PROVIDERS[provider];
-        printSuccess(`BYOK mode — ${providerConfig.name} (no message limits)`);
+/** Guided setup for first-time users who have no AI experience */
+async function guidedSetup() {
+    console.log(banner(VERSION));
+    console.log();
+    console.log(chalk.bold('  Welcome! Let\'s get you set up.'));
+    console.log();
+    console.log(chalk.dim('  K:BOT needs an AI brain to work. You have two options:'));
+    console.log();
+    console.log(`  ${chalk.bold('1.')} ${chalk.hex('#6B8E6B')('Free & Private')} — Run AI on your computer (no account needed)`);
+    console.log(`  ${chalk.bold('2.')} ${chalk.hex('#5B8BA0')('Cloud AI')} — Use an API key from OpenAI, Google, Anthropic, etc.`);
+    console.log();
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const choice = await new Promise((resolve) => {
+        rl.question('  Pick 1 or 2 (or q to quit): ', (answer) => {
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+    if (choice === 'q' || choice === 'quit') {
+        rl.close();
+        return null;
     }
-    console.log(matrixConnect(byok ? 'byok' : tier, agentCount));
-    if (context.isGitRepo) {
-        printInfo(`Project: ${context.repoRoot?.split('/').pop() || 'unknown'} (${context.language || 'unknown'})`);
-        printInfo(`Branch: ${context.branch || 'unknown'}`);
+    if (choice === '1' || choice === 'free' || choice === 'local') {
+        rl.close();
+        console.log();
+        // Check if Ollama is already installed and running
+        const running = await isOllamaRunning();
+        if (running) {
+            const models = await listOllamaModels();
+            if (models.length > 0) {
+                const ok = await setupOllama();
+                if (ok) {
+                    printSuccess(`Found Ollama with ${models.length} model(s). You're ready!`);
+                    return { local: true };
+                }
+            }
+            else {
+                printInfo('Ollama is running but has no models. Downloading one now...');
+                try {
+                    const { execSync } = await import('node:child_process');
+                    printInfo('Pulling llama3.2:3b (small & fast, 2GB download)...');
+                    execSync('ollama pull llama3.2:3b', { stdio: 'inherit', timeout: 600_000 });
+                    const ok = await setupOllama('llama3.2:3b');
+                    if (ok) {
+                        printSuccess('Done! Local AI is ready.');
+                        return { local: true };
+                    }
+                }
+                catch {
+                    printError('Download failed. Try manually: ollama pull llama3.2:3b');
+                    return null;
+                }
+            }
+        }
+        // Ollama not running or not installed
+        console.log(chalk.bold('  To run AI locally, you need Ollama (free, 1 minute install):'));
         console.log();
+        console.log(`  ${chalk.bold('Step 1:')} Download Ollama from ${chalk.underline('https://ollama.com')}`);
+        console.log(`  ${chalk.bold('Step 2:')} Open the Ollama app (it runs in the background)`);
+        console.log(`  ${chalk.bold('Step 3:')} Run: ${chalk.cyan('kbot')} again — it will auto-detect Ollama`);
+        console.log();
+        printInfo('Ollama is like having ChatGPT on your computer — free, private, no account needed.');
+        console.log();
+        return null;
     }
-    printInfo('Type a message, or /help for commands.');
-    console.log();
+    if (choice === '2' || choice === 'cloud' || choice === 'api') {
+        console.log();
+        console.log(chalk.dim('  Paste your API key below. K:BOT will auto-detect which service it\'s from.'));
+        console.log();
+        console.log(chalk.dim('  Where to get a key:'));
+        console.log(chalk.dim('    OpenAI:    https://platform.openai.com/api-keys'));
+        console.log(chalk.dim('    Google:    https://aistudio.google.com/apikey'));
+        console.log(chalk.dim('    Anthropic: https://console.anthropic.com/settings/keys'));
+        console.log();
+        const key = await new Promise((resolve) => {
+            rl.question('  API key: ', (answer) => {
+                resolve(answer.trim());
+                rl.close();
+            });
+        });
+        if (!key || key.length < 10) {
+            printError('That doesn\'t look like a valid API key. Try again with: kbot auth');
+            return null;
+        }
+        let provider = detectProvider(key);
+        if (!provider) {
+            // Ask which provider with simple numbered list
+            console.log();
+            console.log(chalk.dim('  Couldn\'t auto-detect the provider. Which service is this key for?'));
+            const mainProviders = [
+                { id: 'openai', name: 'OpenAI (ChatGPT)' },
+                { id: 'google', name: 'Google (Gemini)' },
+                { id: 'anthropic', name: 'Anthropic (Claude)' },
+                { id: 'mistral', name: 'Mistral AI' },
+                { id: 'deepseek', name: 'DeepSeek' },
+                { id: 'groq', name: 'Groq' },
+            ];
+            for (let i = 0; i < mainProviders.length; i++) {
+                console.log(`  ${i + 1}. ${mainProviders[i].name}`);
+            }
+            console.log();
+            const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+            const providerChoice = await new Promise((resolve) => {
+                rl2.question('  Enter number: ', (a) => { resolve(a.trim()); rl2.close(); });
+            });
+            const idx = parseInt(providerChoice, 10) - 1;
+            if (idx >= 0 && idx < mainProviders.length) {
+                provider = mainProviders[idx].id;
+            }
+            else {
+                printError('Invalid choice. Run kbot auth to try again.');
+                return null;
+            }
+        }
+        printInfo(`Setting up ${PROVIDERS[provider].name}...`);
+        const ok = await setupByok(key, provider);
+        if (ok) {
+            console.log();
+            printSuccess(`Connected to ${PROVIDERS[provider].name}! You're ready.`);
+            return { local: isLocalProvider(provider) };
+        }
+        else {
+            printError('Could not verify that key. Double-check it and try: kbot auth');
+            return null;
+        }
+    }
+    rl.close();
+    printError('Pick 1 or 2. Run kbot again to retry.');
+    return null;
+}
+async function startRepl(agentOpts, context, tier, byokActive = false, localActive = false) {
+    console.log(banner(VERSION));
+    // Show provider status — one clean line
+    if (localActive) {
+        const config = loadConfig();
+        const provider = config?.byok_provider;
+        if (provider === 'ollama') {
+            const models = await warmOllamaModelCache();
+            printInfo(`Ollama · ${models.length} models · free`);
+        }
+        else if (provider === 'openclaw') {
+            printInfo('OpenClaw · local · free');
+        }
+    }
+    else if (byokActive) {
+        const config = loadConfig();
+        const p = config?.byok_provider ? PROVIDERS[config.byok_provider] : null;
+        if (p)
+            printInfo(`${p.name}`);
+    }
+    const sessionCount = incrementSessions();
     const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
         prompt: kbotPrompt(),
     });
+    // First time? Show a gentle hint
+    if (sessionCount <= 1) {
+        printInfo('Try: "hello" or "create a python script" or /help');
+    }
+    console.log();
     rl.prompt();
-    rl.on('line', async (line) => {
+    let processing = false;
+    rl.on('line', (line) => {
         const input = line.trim();
         if (!input) {
             rl.prompt();
             return;
         }
-        // Slash commands
-        if (input.startsWith('/')) {
-            try {
-                await handleSlashCommand(input, agentOpts, rl);
-            }
-            catch (err) {
-                printError(err instanceof Error ? err.message : String(err));
-            }
-            rl.prompt();
+        if (processing)
             return;
-        }
-        // Run agent
-        try {
-            const response = await runAgent(input, agentOpts);
-            printResponse(response.agent, response.content);
-            if (response.usage) {
-                const { input_tokens, output_tokens, cost_usd } = response.usage;
-                printInfo(`${response.agent} · ${response.model} · ${input_tokens + output_tokens} tokens · $${cost_usd.toFixed(4)}${response.toolCalls > 0 ? ` · ${response.toolCalls} tool calls` : ''}`);
+        processing = true;
+        rl.pause();
+        // Move cursor up and clear the echoed line to prevent double-display
+        process.stdout.write('\x1b[A\x1b[2K');
+        // Re-print the input cleanly with the prompt prefix
+        console.log(`${kbotPrompt()}${input}`);
+        const handle = async () => {
+            // Slash commands
+            if (input.startsWith('/')) {
+                try {
+                    await handleSlashCommand(input, agentOpts, rl);
+                }
+                catch (err) {
+                    printError(err instanceof Error ? err.message : String(err));
+                }
             }
-            else if (response.agent === 'local') {
-                // Local execution — no tokens used, already printed by agent.ts
+            else {
+                // Run agent
+                try {
+                    const response = await runAgent(input, agentOpts);
+                    // Only print response if it wasn't already streamed to stdout
+                    if (!response.streamed) {
+                        printResponse(response.agent, response.content);
+                    }
+                    // Usage footer — subtle, compact like Claude Code
+                    if (response.usage) {
+                        const tokens = response.usage.input_tokens + response.usage.output_tokens;
+                        const cost = response.usage.cost_usd === 0 ? 'free' : `$${response.usage.cost_usd.toFixed(4)}`;
+                        const tools = response.toolCalls > 0 ? ` · ${response.toolCalls} tools` : '';
+                        printInfo(`${tokens} tokens${tools} · ${cost}`);
+                    }
+                }
+                catch (err) {
+                    printError(err instanceof Error ? err.message : String(err));
+                }
             }
-        }
-        catch (err) {
+            console.log();
+            processing = false;
+            rl.resume();
+            rl.prompt();
+        };
+        handle().catch((err) => {
             printError(err instanceof Error ? err.message : String(err));
-        }
-        console.log();
-        rl.prompt();
+            processing = false;
+            rl.resume();
+            rl.prompt();
+        });
     });
     // Ctrl+C: don't exit immediately — just cancel current input and re-prompt
+    let sigintCount = 0;
     rl.on('SIGINT', () => {
+        sigintCount++;
+        if (sigintCount >= 2) {
+            printGoodbye();
+            process.exit(0);
+        }
         console.log(); // newline after ^C
-        printInfo('Press Ctrl+C again or type /quit to exit.');
+        printInfo('Ctrl+C again to exit');
         rl.prompt();
+        // Reset after 2 seconds
+        setTimeout(() => { sigintCount = 0; }, 2000);
     });
-    rl.on('close', () => {
-        printGoodbye();
-        process.exit(0);
+    // Keep process alive until readline closes
+    return new Promise((resolve) => {
+        rl.on('close', () => {
+            // Flush all pending learning writes before exit
+            flushPendingWrites();
+            printGoodbye();
+            resolve();
+            process.exit(0);
+        });
     });
 }
+async function handleMatrixCommand(args) {
+    const sub = args[0];
+    if (!sub || sub === 'list') {
+        printInfo('Agent Creation Matrix');
+        console.log(formatAgentList());
+        console.log();
+        printInfo('Presets: ' + Object.keys(PRESETS).join(', '));
+        printInfo('Usage: /matrix create <name> <prompt>');
+        printInfo('       /matrix preset <name>');
+        printInfo('       /matrix remove <id>');
+        printInfo('       /matrix info <id>');
+        return;
+    }
+    if (sub === 'create') {
+        const name = args[1];
+        if (!name) {
+            printError('Usage: /matrix create <name> <system prompt...>');
+            return;
+        }
+        const prompt = args.slice(2).join(' ');
+        if (!prompt) {
+            printError('System prompt required. Example:');
+            printInfo('  /matrix create "Security Bot" You are a security expert who finds vulnerabilities.');
+            return;
+        }
+        try {
+            const agent = createAgent(name, prompt);
+            printSuccess(`Agent "${agent.name}" created (${agent.id})`);
+            printInfo(`Use with: /agent ${agent.id}`);
+        }
+        catch (err) {
+            printError(err instanceof Error ? err.message : String(err));
+        }
+        return;
+    }
+    if (sub === 'preset') {
+        const presetId = args[1];
+        if (!presetId || !PRESETS[presetId]) {
+            printError(`Unknown preset. Available: ${Object.keys(PRESETS).join(', ')}`);
+            return;
+        }
+        const preset = PRESETS[presetId];
+        try {
+            const agent = createAgent(preset.name, preset.prompt);
+            printSuccess(`Preset agent "${agent.name}" spawned (${agent.id})`);
+            printInfo(`Use with: /agent ${agent.id}`);
+        }
+        catch (err) {
+            printError(err instanceof Error ? err.message : String(err));
+        }
+        return;
+    }
+    if (sub === 'remove') {
+        const id = args[1];
+        if (!id) {
+            printError('Usage: /matrix remove <agent-id>');
+            return;
+        }
+        if (removeAgent(id)) {
+            printSuccess(`Agent "${id}" removed from matrix`);
+        }
+        else {
+            printError(`Agent "${id}" not found`);
+        }
+        return;
+    }
+    if (sub === 'info') {
+        const id = args[1];
+        if (!id) {
+            printError('Usage: /matrix info <agent-id>');
+            return;
+        }
+        const agent = getAgent(id);
+        if (agent) {
+            console.log(formatAgentDetail(agent));
+        }
+        else {
+            printError(`Agent "${id}" not found`);
+        }
+        return;
+    }
+    printError(`Unknown matrix command: ${sub}`);
+    printInfo('Available: list, create, preset, remove, info');
+}
 async function handleSlashCommand(input, opts, rl) {
     const [cmd, ...args] = input.slice(1).split(' ');
     switch (cmd) {
@@ -284,26 +978,41 @@ async function handleSlashCommand(input, opts, rl) {
             }
             else {
                 printInfo(`Current agent: ${opts.agent || 'auto'}`);
-                printInfo('Available: kernel, researcher, coder, writer, analyst (+ more with Growth tier)');
+                printInfo('Built-in: kernel, researcher, coder, writer, analyst, aesthete, guardian, curator, strategist');
+                const matrixIds = getMatrixAgentIds();
+                if (matrixIds.length > 0) {
+                    printInfo(`Matrix: ${matrixIds.join(', ')}`);
+                }
             }
             break;
+        case 'matrix':
+            await handleMatrixCommand(args);
+            break;
         case 'model':
             if (args[0]) {
-                opts.model = args[0];
-                printSuccess(`Model set to: ${args[0]}`);
+                const config = loadConfig();
+                // If using Ollama, update the default model in the provider config
+                if (config?.byok_provider === 'ollama') {
+                    PROVIDERS.ollama.defaultModel = args[0];
+                    printSuccess(`Ollama model set to: ${args[0]}`);
+                    printInfo('This model will be used for all requests (overrides smart routing)');
+                }
+                else {
+                    opts.model = args[0];
+                    printSuccess(`Model set to: ${args[0]}`);
+                }
             }
             else {
-                printInfo(`Current model: ${opts.model || 'auto'}`);
+                const config = loadConfig();
+                if (config?.byok_provider === 'ollama') {
+                    printInfo(`Current model: ${PROVIDERS.ollama.defaultModel} (Ollama, smart routing active)`);
+                    printInfo('Override with: /model <name>  or  /model auto');
+                }
+                else {
+                    printInfo(`Current model: ${opts.model || 'auto'}`);
+                }
             }
             break;
-        case 'usage': {
-            const stats = await getUsageStats();
-            if (stats)
-                printUsage(stats);
-            else
-                printError('Could not fetch usage stats');
-            break;
-        }
         case 'clear':
             clearHistory();
             printSuccess('Conversation history cleared');
@@ -328,6 +1037,377 @@ async function handleSlashCommand(input, opts, rl) {
                 printInfo(mem || 'No memory entries yet');
             }
             break;
+        case 'learn':
+        case 'stats': {
+            const stats = getExtendedStats();
+            console.log();
+            console.log(chalk.bold('  Learning'));
+            printInfo(`  ${stats.patternsCount} patterns · ${stats.solutionsCount} solutions · ${stats.knowledgeCount} facts`);
+            printInfo(`  ${stats.totalMessages} messages · ${stats.sessions} sessions · ${stats.efficiency} efficiency`);
+            if (stats.topKnowledge.length > 0) {
+                console.log();
+                for (const fact of stats.topKnowledge.slice(0, 5)) {
+                    printInfo(`  • ${fact}`);
+                }
+            }
+            break;
+        }
+        case 'remember': {
+            const fact = args.join(' ');
+            if (!fact) {
+                printError('Usage: /remember <fact to remember>');
+                printInfo('Example: /remember My API runs on port 3001');
+            }
+            else {
+                learnFact(fact, 'fact', 'user-taught');
+                printSuccess(`Learned: "${fact}"`);
+            }
+            break;
+        }
+        case 'compact': {
+            const result = compactHistory();
+            printSuccess(result.summary);
+            break;
+        }
+        case 'save': {
+            const sessionName = args.join(' ') || undefined;
+            try {
+                const session = saveSession(sessionName, opts.agent);
+                printSuccess(`Session saved: ${session.name} (${session.id})`);
+                printInfo('Resume with: /resume ' + session.id);
+            }
+            catch (err) {
+                printError(err instanceof Error ? err.message : String(err));
+            }
+            break;
+        }
+        case 'resume': {
+            const sessionId = args.join(' ');
+            if (!sessionId) {
+                printError('Usage: /resume <session-id or name>');
+                printInfo('Run /sessions to list saved sessions.');
+            }
+            else {
+                const session = loadSession(sessionId);
+                if (session) {
+                    restoreHistory(session.history);
+                    if (session.agent)
+                        opts.agent = session.agent;
+                    printSuccess(`Resumed: ${session.name} (${session.turnCount} turns)`);
+                }
+                else {
+                    printError(`Session not found: ${sessionId}`);
+                }
+            }
+            break;
+        }
+        case 'sessions': {
+            const sessions = listSessions();
+            printInfo('Saved Sessions');
+            console.log(formatSessionList(sessions));
+            break;
+        }
+        case 'delete-session': {
+            const id = args.join(' ');
+            if (!id) {
+                printError('Usage: /delete-session <session-id>');
+            }
+            else if (deleteSession(id)) {
+                printSuccess(`Session deleted: ${id}`);
+            }
+            else {
+                printError(`Session not found: ${id}`);
+            }
+            break;
+        }
+        case 'train': {
+            printInfo('Running self-training...');
+            const result = selfTrain();
+            printSuccess('Training complete');
+            console.log();
+            for (const line of result.summary.split('\n')) {
+                printInfo(`  ${line}`);
+            }
+            const log = getTrainingLog();
+            console.log();
+            printInfo(`  Total training runs: ${log.runsTotal}`);
+            printInfo(`  Total entries pruned: ${log.entriesPruned}`);
+            printInfo(`  Total insights synthesized: ${log.insightsSynthesized}`);
+            break;
+        }
+        case 'thinking':
+            opts.thinking = !opts.thinking;
+            printSuccess(`Extended thinking: ${opts.thinking ? 'ON' : 'OFF'}`);
+            if (opts.thinking)
+                printInfo('AI will show reasoning steps before responding.');
+            break;
+        case 'plan': {
+            const planTask = args.join(' ');
+            if (!planTask) {
+                printError('Usage: /plan <task description>');
+                printInfo('Example: /plan refactor the auth system to use JWT');
+            }
+            else {
+                const { autonomousExecute } = await import('./planner.js');
+                const plan = await autonomousExecute(planTask, opts, {
+                    onApproval: async (plan) => {
+                        const { createInterface: createRl } = await import('node:readline');
+                        const confirmRl = createRl({ input: process.stdin, output: process.stdout });
+                        const answer = await new Promise((resolve) => {
+                            confirmRl.question('  Approve this plan? [y/N] ', (a) => {
+                                resolve(a.trim().toLowerCase());
+                                confirmRl.close();
+                            });
+                        });
+                        return answer === 'y' || answer === 'yes';
+                    },
+                });
+                const { formatPlanSummary } = await import('./planner.js');
+                printInfo(formatPlanSummary(plan));
+            }
+            break;
+        }
+        case 'worktree': {
+            if (!args[0] || args[0] === 'list') {
+                const { executeTool: execTool } = await import('./tools/index.js');
+                const result = await execTool({ id: 'cli_wt', name: 'worktree_list', arguments: {} });
+                printInfo(result.result);
+            }
+            else if (args[0] === 'create') {
+                const { executeTool: execTool } = await import('./tools/index.js');
+                const result = await execTool({ id: 'cli_wt', name: 'worktree_create', arguments: { name: args[1] } });
+                printInfo(result.result);
+            }
+            else if (args[0] === 'switch') {
+                const { executeTool: execTool } = await import('./tools/index.js');
+                const result = await execTool({ id: 'cli_wt', name: 'worktree_switch', arguments: { id: args[1] } });
+                printInfo(result.result);
+            }
+            else if (args[0] === 'merge') {
+                const { executeTool: execTool } = await import('./tools/index.js');
+                const result = await execTool({ id: 'cli_wt', name: 'worktree_merge', arguments: { id: args[1] } });
+                printInfo(result.result);
+            }
+            else if (args[0] === 'remove') {
+                const { executeTool: execTool } = await import('./tools/index.js');
+                const result = await execTool({ id: 'cli_wt', name: 'worktree_remove', arguments: { id: args[1] } });
+                printInfo(result.result);
+            }
+            else {
+                printError('Usage: /worktree [list|create|switch|merge|remove] [args]');
+            }
+            break;
+        }
+        case 'permission': {
+            const { setPermissionMode, getPermissionMode } = await import('./permissions.js');
+            const mode = args[0];
+            if (mode === 'permissive' || mode === 'normal' || mode === 'strict') {
+                setPermissionMode(mode);
+                printSuccess(`Permission mode: ${mode}`);
+            }
+            else {
+                printInfo(`Current permission mode: ${getPermissionMode()}`);
+                printInfo('Available: permissive, normal, strict');
+            }
+            break;
+        }
+        case 'plugins': {
+            const { getLoadedPlugins, formatPluginList, scaffoldPlugin } = await import('./plugins.js');
+            if (args[0] === 'create' && args[1]) {
+                const result = scaffoldPlugin(args[1]);
+                printInfo(result);
+            }
+            else if (args[0] === 'reload') {
+                const { loadPlugins } = await import('./plugins.js');
+                const plugins = await loadPlugins(true);
+                printSuccess(`Reloaded ${plugins.length} plugin(s)`);
+            }
+            else {
+                printInfo(formatPluginList());
+            }
+            break;
+        }
+        case 'dashboard': {
+            const { renderDashboard } = await import('./tui.js');
+            const config = loadConfig();
+            const stats = getExtendedStats();
+            const dashState = {
+                agent: opts.agent || 'auto',
+                model: opts.model || 'auto',
+                provider: config?.byok_provider || 'anthropic',
+                toolsUsed: stats.totalMessages,
+                tokensUsed: 0,
+                cost: 0,
+                sessionTurns: 0,
+                activeSubagents: [],
+                recentTools: [],
+            };
+            console.log(renderDashboard(dashState));
+            break;
+        }
+        case 'build': {
+            const { detectProjectTargets, formatTargetList, getMissingTools } = await import('./build-targets.js');
+            const detected = detectProjectTargets();
+            if (detected.length === 0) {
+                printInfo('No build targets detected in this project.');
+                printInfo('Use: /build targets — to see all supported platforms');
+            }
+            else if (args[0] === 'targets') {
+                const { BUILD_TARGETS } = await import('./build-targets.js');
+                console.log(formatTargetList(Object.values(BUILD_TARGETS)));
+            }
+            else {
+                printInfo('Detected build targets:');
+                for (const t of detected) {
+                    const missing = getMissingTools(t);
+                    const icon = missing.length === 0 ? '✓' : '○';
+                    printInfo(`  ${icon} ${t.id.padEnd(16)} ${t.name}`);
+                }
+                console.log();
+                printInfo('Run: kbot "build for <target>" to trigger a build');
+            }
+            break;
+        }
+        case 'ollama': {
+            if (args[0] === 'off') {
+                disableByok();
+                printSuccess('Ollama disabled. Provider disabled.');
+                break;
+            }
+            const running = await isOllamaRunning();
+            if (!running) {
+                printError('Ollama not running. Start with: ollama serve');
+                break;
+            }
+            if (args[0] === 'list') {
+                const models = await listOllamaModels();
+                printInfo('Available Ollama models:');
+                for (const m of models)
+                    printInfo(`  • ${m}`);
+                break;
+            }
+            const model = args[0];
+            const ok = await setupOllama(model);
+            if (ok) {
+                const models = await listOllamaModels();
+                printSuccess(`Ollama enabled! ${models.length} models available. $0 cost.`);
+                printInfo(`Default: ${model || PROVIDERS.ollama.defaultModel}`);
+            }
+            else {
+                printError('Failed to connect to Ollama.');
+            }
+            break;
+        }
+        case 'openclaw': {
+            if (args[0] === 'off') {
+                disableByok();
+                printSuccess('OpenClaw disabled.');
+                break;
+            }
+            const ok = await setupOpenClaw(args[0]);
+            if (ok) {
+                printSuccess('OpenClaw gateway connected at 127.0.0.1:18789');
+            }
+            else {
+                printError('Cannot connect to OpenClaw gateway.');
+            }
+            break;
+        }
+        case 'models': {
+            const config = loadConfig();
+            if (config?.byok_provider === 'ollama') {
+                const running = await isOllamaRunning();
+                if (!running) {
+                    printError('Ollama not running');
+                    break;
+                }
+                const models = await listOllamaModels();
+                printInfo('Available local models:');
+                for (const m of models) {
+                    const active = m === (PROVIDERS.ollama.defaultModel) ? ' (active)' : '';
+                    printInfo(`  ${active ? '>' : ' '} ${m}${active}`);
+                }
+                console.log();
+                printInfo('Switch model: /model <name>');
+                printInfo('Smart routing auto-selects: coding → qwen2.5-coder · reasoning → phi4 · general → llama3.1');
+            }
+            else if (config?.byok_provider) {
+                const p = PROVIDERS[config.byok_provider];
+                printInfo(`Provider: ${p.name}`);
+                printInfo(`  Default: ${p.defaultModel}`);
+                printInfo(`  Fast:    ${p.fastModel}`);
+            }
+            else {
+                printInfo('No provider configured. Run: kbot byok');
+            }
+            break;
+        }
+        case 'provider': {
+            const config = loadConfig();
+            if (config?.byok_enabled && config?.byok_provider) {
+                const p = PROVIDERS[config.byok_provider];
+                printInfo(`Active provider: ${p?.name || config.byok_provider}`);
+                printInfo(`  Model: ${p?.defaultModel || 'unknown'}`);
+                printInfo(`  Cost: $${p?.inputCost || 0}/${p?.outputCost || 0} per 1M tokens`);
+                printInfo(`  Local: ${isLocalProvider(config.byok_provider) ? 'Yes (free, private)' : 'No (cloud)'}`);
+            }
+            else {
+                printInfo('No provider configured. Run: kbot byok');
+            }
+            printInfo('');
+            printInfo('Switch: /ollama [model] | /openclaw | kbot byok');
+            break;
+        }
+        case 'mimic': {
+            if (!args[0] || args[0] === 'list') {
+                const profiles = listMimicProfiles();
+                printInfo('Mimic Matrix — Code like the best tools and frameworks');
+                console.log();
+                printInfo('  Tool Styles:');
+                for (const p of profiles.filter(p => ['claude-code', 'cursor', 'copilot'].includes(p.id))) {
+                    const color = chalk.hex(p.color);
+                    printInfo(`    ${color(p.icon)} ${p.id.padEnd(16)} ${p.description}`);
+                }
+                console.log();
+                printInfo('  Framework Experts:');
+                for (const p of profiles.filter(p => ['nextjs', 'react', 'python', 'rust'].includes(p.id))) {
+                    const color = chalk.hex(p.color);
+                    printInfo(`    ${color(p.icon)} ${p.id.padEnd(16)} ${p.description}`);
+                }
+                console.log();
+                printInfo('  Coding Philosophies:');
+                for (const p of profiles.filter(p => ['senior', 'startup'].includes(p.id))) {
+                    const color = chalk.hex(p.color);
+                    printInfo(`    ${color(p.icon)} ${p.id.padEnd(16)} ${p.description}`);
+                }
+                console.log();
+                printInfo('Activate: /mimic <id>     Example: /mimic nextjs');
+                printInfo('Deactivate: /mimic off');
+            }
+            else if (args[0] === 'off') {
+                opts.agent = 'auto';
+                printSuccess('Mimic mode deactivated. Back to auto-routing.');
+            }
+            else {
+                const profileId = args[0];
+                const agent = activateMimic(profileId);
+                if (agent) {
+                    opts.agent = agent.id;
+                    const color = chalk.hex(agent.color);
+                    printSuccess(`Mimic activated: ${color(agent.icon)} ${agent.name}`);
+                    const profile = getMimicProfile(profileId);
+                    if (profile?.conventions) {
+                        printInfo(`Conventions: ${profile.conventions.join(' · ')}`);
+                    }
+                    printInfo('All responses will follow this style. Deactivate with: /mimic off');
+                }
+                else {
+                    printError(`Unknown mimic profile: ${profileId}`);
+                    printInfo('Run /mimic to see available profiles');
+                }
+            }
+            break;
+        }
         case 'quit':
         case 'exit':
             rl.close();