@kernel.chat/kbot 3.22.0 → 3.26.0

package/dist/agents/trader.js

@@ -0,0 +1,190 @@
+// kbot Trader Specialist Agent
+// Financial analysis, portfolio management, paper trading, and crypto market intelligence.
+// Uses free APIs (CoinGecko, DeFiLlama, Alternative.me) — no API keys required.
+//
+// GUARDRAILS: Paper trading by default. Real trades require explicit wallet config.
+// Not financial advice — always includes disclaimers.
+/** Trader agent definition — matches the shape used by PRESETS and BUILTIN_AGENTS in matrix.ts */
+export const TRADER_PRESET = {
+    name: 'Trader',
+    prompt: `You are the kbot Trader agent — a quantitative finance specialist for crypto markets, DeFi, and portfolio management.
+
+## Your Capabilities
+
+### Market Intelligence
+- **market_data** — Real-time price, market cap, volume, 24h change for 10,000+ tokens
+- **market_overview** — Full market snapshot: BTC dominance, top coins, macro view
+- **price_history** — Historical OHLCV data for any timeframe
+- **market_sentiment** — Fear & Greed Index, trending coins, social signals
+- **defi_yields** — Top DeFi yield opportunities across all chains
+
+### Technical Analysis
+- **technical_analysis** — RSI, SMA/EMA, MACD, Bollinger Bands with actionable signals
+- Use multiple indicators together — never trade on a single signal
+- Always state the timeframe and confidence level
+
+### Paper Trading
+- **paper_trade** — Virtual $100,000 portfolio for strategy testing
+- Enforces risk limits: max 25% in one position, 15% stop loss, 5% max daily loss
+- Track all trades with P&L history
+- Use this to backtest strategies before risking real money
+
+### Social Sentiment Intelligence
+- **social_pulse** — Combined Reddit + news + Fear & Greed for any token/stock (THE morning briefing tool)
+- **reddit_sentiment** — Scan r/cryptocurrency, r/wallstreetbets, etc. with sentiment scoring
+- **crypto_news** — News aggregator with bullish/bearish classification
+- **github_activity** — Monitor dev velocity on crypto project repos (bullish fundamental signal)
+- **whale_tracker** — Large Solana transactions (whale movements signal price action)
+
+### Wallet Monitoring
+- **wallet_balance** — Check any Solana or Ethereum wallet (read-only, no keys needed)
+
+## Trading Framework
+
+When analyzing a trade opportunity, always follow this structure:
+
+### 1. Signal
+- What triggered this? (Technical breakout, sentiment shift, fundamental event)
+- Which indicators confirm? (RSI, MACD, volume, trend)
+- Timeframe: scalp (minutes), swing (days), position (weeks)
+
+### 2. Risk Assessment
+- Position size relative to portfolio (never exceed 25%)
+- Stop loss level and reasoning
+- Risk/reward ratio (minimum 2:1 for entries)
+- Correlation with existing positions
+
+### 3. Execution Plan
+- Entry price or range
+- Take-profit targets (scale out: 50% at TP1, 25% at TP2, trail rest)
+- Stop loss (hard stop, no moving it down)
+- Timeline and invalidation conditions
+
+## Rules
+
+1. **Paper trading first** — Always test strategies with paper_trade before suggesting real money moves.
+2. **Risk management is non-negotiable** — Never suggest all-in trades. Always have a stop loss.
+3. **Multiple confirmations** — Never trade on a single indicator. Need at least 3 confirming signals.
+4. **Disclaimers** — Always note: "Not financial advice. Past performance doesn't guarantee future results."
+5. **Be honest about uncertainty** — Crypto is volatile. Say "I don't know" when appropriate.
+6. **No leverage suggestions for beginners** — Only discuss leverage if user explicitly asks and understands risks.
+7. **DeFi due diligence** — Always warn about smart contract risk, impermanent loss, and rug pull indicators.
+
+## When the user asks for a "daily briefing":
+1. Run market_overview for top 10
+2. Run market_sentiment for Fear & Greed
+3. Run social_pulse on BTC (combined Reddit + news + mood)
+4. Run technical_analysis on BTC and ETH
+5. Run market_indices for stock market context (S&P, VIX)
+6. Check their paper_trade portfolio status
+7. Synthesize into actionable insights with clear BUY/SELL/HOLD signals
+
+## When the user says "analyze X":
+1. market_data for current state
+2. price_history for 90d trend
+3. technical_analysis for signals
+4. social_pulse for Reddit + news sentiment
+5. github_activity if it's a crypto project (check dev velocity)
+6. Give a clear BULLISH / BEARISH / NEUTRAL verdict with reasoning across all signals
+
+## Strategy Templates
+
+When the user asks to "set up a strategy" or "automate trading", recommend one of these:
+
+### DCA (Dollar-Cost Averaging)
+- Best for: long-term accumulation, beginners
+- How: buy fixed USD amount at regular intervals regardless of price
+- Backtest with: \`backtest_strategy symbol dca days 365\`
+- Risk: low (time smooths volatility)
+
+### Momentum (RSI-based)
+- Best for: swing traders, intermediate users
+- How: buy when RSI drops below 30 (oversold), sell when RSI rises above 70 (overbought)
+- Backtest with: \`backtest_strategy symbol momentum days 180\`
+- Risk: medium (can miss rallies, false signals in strong trends)
+
+### Mean Reversion (Bollinger Bands)
+- Best for: range-bound markets, experienced traders
+- How: buy below lower Bollinger Band, sell above upper Band
+- Backtest with: \`backtest_strategy symbol mean-reversion days 180\`
+- Risk: medium-high (fails in breakout/breakdown markets)
+
+### Portfolio Rebalance
+- Best for: diversified holders
+- How: set target allocation (e.g. "btc:50,eth:30,sol:20"), rebalance monthly
+- Use: \`portfolio_rebalance targets "btc:50,eth:30,sol:20"\`
+
+## Stock Market Tools
+
+You also have access to traditional equities:
+- **stock_quote** — real-time stock/ETF quotes (AAPL, SPY, etc.)
+- **stock_history** — historical price data (1mo–max range)
+- **stock_compare** — compare multiple tickers side by side
+- **stock_search** — find stocks by name/keyword
+- **stock_screener** — curated watchlists by sector (tech, ai, energy, etc.)
+- **market_indices** — S&P 500, Nasdaq, Dow, VIX, global indices
+
+When analyzing stocks, use the same Signal → Risk → Execution framework as crypto.
+
+## Price Alerts
+- **price_alert set** — set above/below thresholds
+- **price_alert check** — check if any alerts triggered
+- **price_alert list** — show all active alerts
+
+## Wallet Operations
+- **wallet_list** — show all wallets
+- **wallet_switch** — change active wallet
+- **wallet_send** — send SOL (with confirmation gate)
+- **wallet_tokens** — all token balances with USD values
+
+*Built for research and paper trading. Not a licensed financial advisor. Not financial advice.*`,
+};
+/** Trader agent built-in registration — matches BUILTIN_AGENTS shape in matrix.ts */
+export const TRADER_BUILTIN = {
+    name: 'Trader',
+    icon: '📈',
+    color: '#10B981', // emerald green — money/growth
+    prompt: TRADER_PRESET.prompt,
+};
+/** Trader agent keyword list for learned-router.ts */
+export const TRADER_KEYWORDS = [
+    'trade', 'trading', 'buy', 'sell', 'portfolio', 'stock', 'crypto',
+    'bitcoin', 'btc', 'ethereum', 'eth', 'solana', 'sol', 'token',
+    'price', 'market', 'chart', 'candle', 'ohlcv', 'volume',
+    'rsi', 'macd', 'bollinger', 'sma', 'ema', 'moving average',
+    'technical analysis', 'fundamental', 'sentiment', 'fear', 'greed',
+    'wallet', 'balance', 'defi', 'yield', 'apy', 'apr', 'staking',
+    'swap', 'dex', 'cex', 'exchange', 'binance', 'coinbase',
+    'long', 'short', 'position', 'stop loss', 'take profit',
+    'bull', 'bear', 'bullish', 'bearish', 'pump', 'dump', 'moon',
+    'altcoin', 'memecoin', 'nft', 'airdrop', 'rug', 'whale',
+    'paper trade', 'backtest', 'strategy', 'hedge', 'arbitrage',
+    'leverage', 'margin', 'liquidation', 'futures', 'options',
+    'market cap', 'dominance', 'tvl', 'gas', 'fees',
+    'finance', 'financial', 'investment', 'invest', 'money',
+    'reddit', 'wsb', 'wallstreetbets', 'social', 'pulse', 'news',
+    'whale', 'whale tracker', 'large transaction', 'briefing',
+    'screener', 'watchlist', 'sector', 'index', 'indices', 'vix',
+    's&p', 'nasdaq', 'dow', 'spy', 'qqq', 'etf',
+    'aapl', 'msft', 'googl', 'nvda', 'tsla', 'amzn',
+];
+/** Trader agent routing patterns for learned-router.ts */
+export const TRADER_PATTERNS = [
+    /\b(buy|sell|trade|swap)\b.+\b(btc|eth|sol|crypto|token|coin)\b/i,
+    /\b(price|chart|analysis)\b.+\b(bitcoin|ethereum|solana|crypto)\b/i,
+    /\b(portfolio|position|balance|wallet)\b/i,
+    /\b(bull|bear|long|short|hedge)\b.+\b(market|crypto|trade)\b/i,
+    /\b(rsi|macd|bollinger|moving average|technical analysis)\b/i,
+    /\b(defi|yield|staking|apy|tvl)\b/i,
+    /\b(fear.*greed|market sentiment|trending coins)\b/i,
+    /\bpaper\s*trad/i,
+    /\b(how much is|what'?s the price of|check|look up)\b.+\b(btc|eth|sol|bitcoin|ethereum|solana)\b/i,
+];
+/** Entry point for dynamic agent loading */
+export const agent = {
+    preset: TRADER_PRESET,
+    builtin: TRADER_BUILTIN,
+    keywords: TRADER_KEYWORDS,
+    patterns: TRADER_PATTERNS,
+};
+//# sourceMappingURL=trader.js.map

package/dist/agents/trader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trader.js","sourceRoot":"","sources":["../../src/agents/trader.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,2FAA2F;AAC3F,gFAAgF;AAChF,EAAE;AACF,oFAAoF;AACpF,sDAAsD;AAEtD,kGAAkG;AAClG,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gGAkIsF;CAC/F,CAAA;AAED,qFAAqF;AACrF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,IAAI;IACV,KAAK,EAAE,SAAS,EAAE,+BAA+B;IACjD,MAAM,EAAE,aAAa,CAAC,MAAM;CAC7B,CAAA;AAED,sDAAsD;AACtD,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ;IACjE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO;IAC7D,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ;IACvD,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB;IAC1D,oBAAoB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO;IACjE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS;IAC7D,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU;IACvD,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa;IACvD,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAC5D,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO;IACvD,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW;IAC3D,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS;IACzD,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IAC/C,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO;IACvD,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM;IAC5D,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,UAAU;IACzD,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK;IAC5D,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;IAC3C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAChD,CAAA;AAED,0DAA0D;AAC1D,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,iEAAiE;IACjE,mEAAmE;IACnE,0CAA0C;IAC1C,8DAA8D;IAC9D,6DAA6D;IAC7D,mCAAmC;IACnC,oDAAoD;IACpD,iBAAiB;IACjB,kGAAkG;CACnG,CAAA;AAED,4CAA4C;AAC5C,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,MAAM,EAAE,aAAa;IACrB,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,eAAe;IACzB,QAAQ,EAAE,eAAe;CAC1B,CAAA"}

package/dist/cli.js

@@ -15,6 +15,7 @@ import { Command } from 'commander';
 import { loadConfig, setupByok, setupEmbedded, isByokEnabled, isLocalProvider, disableByok, detectProvider, getByokProvider, PROVIDERS, setupOllama, setupKbotLocal, isOllamaRunning, listOllamaModels, warmOllamaModelCache } from './auth.js';
 import { runAndPrint, runAgent, runAgentFromCheckpoint } from './agent.js';
 import { gatherContext } from './context.js';
+import { probeMachine } from './machine.js';
 import { registerCoreTools, startLazyToolRegistration, ensureLazyToolsLoaded } from './tools/index.js';
 import { clearHistory, clearMemory, compactHistory, restoreHistory } from './memory.js';
 import { saveSession, loadSession, listSessions, deleteSession, formatSessionList, } from './sessions.js';
@@ -58,6 +59,50 @@ async function main() {
         .addHelpCommand(false)
         .action(() => { });
     // Sub-commands
+    program
+        .command('help')
+        .description('Show help — commands, agents, support channels')
+        .action(() => {
+        console.log();
+        console.log(`  ${chalk.bold('kbot')} v${VERSION} — Open-source terminal AI agent`);
+        console.log();
+        console.log(`  ${chalk.bold('Quick Start')}`);
+        console.log(`  ${chalk.dim('─'.repeat(50))}`);
+        console.log(`  ${chalk.white('kbot')}                          Interactive REPL`);
+        console.log(`  ${chalk.white('kbot "fix the bug"')}            One-shot prompt`);
+        console.log(`  ${chalk.white('kbot --agent researcher')}       Force a specialist`);
+        console.log(`  ${chalk.white('kbot --model sonnet')}           Override model`);
+        console.log(`  ${chalk.white('kbot local')}                    $0 local AI (no API key)`);
+        console.log();
+        console.log(`  ${chalk.bold('Common Commands')}`);
+        console.log(`  ${chalk.dim('─'.repeat(50))}`);
+        console.log(`  ${chalk.white('kbot auth')}         Configure your API key (20 providers)`);
+        console.log(`  ${chalk.white('kbot doctor')}       Diagnose setup issues`);
+        console.log(`  ${chalk.white('kbot agents')}       List all 25 specialist agents`);
+        console.log(`  ${chalk.white('kbot status')}       Full dashboard — tools, agents, stats`);
+        console.log(`  ${chalk.white('kbot init')}         Set up kbot for this project (60s)`);
+        console.log(`  ${chalk.white('kbot update')}       Update to the latest version`);
+        console.log(`  ${chalk.white('kbot tutorial')}     Guided walkthrough`);
+        console.log();
+        console.log(`  ${chalk.bold('Inside the REPL')}`);
+        console.log(`  ${chalk.dim('─'.repeat(50))}`);
+        console.log(`  ${chalk.white('/help')}             Full command list`);
+        console.log(`  ${chalk.white('/agent <name>')}     Switch specialist`);
+        console.log(`  ${chalk.white('/plan <task>')}      Plan + execute complex tasks`);
+        console.log(`  ${chalk.white('/save')}             Save conversation`);
+        console.log(`  ${chalk.white('/remember <…>')}     Teach kbot something permanent`);
+        console.log();
+        console.log(`  ${chalk.bold('Need Help?')}`);
+        console.log(`  ${chalk.dim('─'.repeat(50))}`);
+        console.log(`  ${chalk.white('kbot doctor')}       ${chalk.dim('— diagnose any setup issue')}`);
+        console.log(`  ${chalk.cyan('https://discord.gg/kdMauM9abG')}  ${chalk.dim('Discord community')}`);
+        console.log(`  ${chalk.cyan('https://github.com/isaacsight/kernel/issues')}  ${chalk.dim('Bug reports')}`);
+        console.log(`  ${chalk.cyan('support@kernel.chat')}  ${chalk.dim('Email (AI-assisted replies)')}`);
+        console.log();
+        console.log(`  ${chalk.dim('25 specialist agents · 290+ tools · 20 providers · MIT licensed')}`);
+        console.log();
+        process.exit(0);
+    });
     program
         .command('version')
         .description('Show kbot version')
@@ -419,11 +464,20 @@ async function main() {
         console.log(chalk.dim(`  Mode: ${config.dryRun ? 'DRY RUN (no posting)' : 'LIVE (will post)'}`));
         console.log(chalk.dim(`  Interval: ${config.pollIntervalMinutes}m`));
         console.log();
-        // Initial cycle
+        // Initial cycle: outreach + extended (tools, agents, papers)
+        const { runExtendedDiscovery } = await import('./discovery.js');
         await runDiscoveryCycle(config);
-        // Poll
+        const extended = await runExtendedDiscovery(config);
+        if (extended.tools > 0)
+            printInfo(`  Discovered ${extended.tools} new tools`);
+        if (extended.agents > 0)
+            printInfo(`  Proposed ${extended.agents} new agents`);
+        if (extended.papers > 0)
+            printInfo(`  Found ${extended.papers} new papers`);
+        // Poll: outreach every interval, extended every 6 hours
         setInterval(() => runDiscoveryCycle(config), config.pollIntervalMinutes * 60 * 1000);
-        console.log(`Polling every ${config.pollIntervalMinutes}m. Ctrl+C to stop.`);
+        setInterval(() => runExtendedDiscovery(config), 6 * 60 * 60 * 1000);
+        console.log(`Polling: outreach every ${config.pollIntervalMinutes}m, tools/agents/papers every 6h. Ctrl+C to stop.`);
         await new Promise(() => { }); // keep alive
     });
     discoveryCmd
@@ -500,6 +554,67 @@ async function main() {
         printSuccess('Credentials updated.');
         process.exit(0);
     });
+    discoveryCmd
+        .command('tools')
+        .description('Show discovered tools from npm, GitHub, MCP servers')
+        .action(async () => {
+        const { getDiscoveredTools } = await import('./discovery.js');
+        const tools = getDiscoveredTools();
+        if (tools.length === 0) {
+            printInfo('No tools discovered yet. Run: kbot discovery start');
+            process.exit(0);
+        }
+        console.log();
+        printInfo(`${tools.length} tools discovered:`);
+        for (const t of tools.slice(-15)) {
+            console.log(`  [${t.source}] ${t.name}`);
+            console.log(`    ${t.description.slice(0, 80)}`);
+            console.log(`    ${t.url}`);
+            console.log();
+        }
+        process.exit(0);
+    });
+    discoveryCmd
+        .command('agents')
+        .description('Show proposed new specialist agents')
+        .action(async () => {
+        const { getProposedAgents } = await import('./discovery.js');
+        const agents = getProposedAgents();
+        if (agents.length === 0) {
+            printInfo('No new agents proposed yet. Run: kbot discovery start');
+            process.exit(0);
+        }
+        console.log();
+        printInfo(`${agents.length} agents proposed:`);
+        for (const a of agents) {
+            console.log(`  ${a.name} (${a.id})`);
+            console.log(`    Why: ${a.reason}`);
+            console.log(`    Prompt: ${a.systemPrompt.slice(0, 100)}...`);
+            console.log();
+        }
+        process.exit(0);
+    });
+    discoveryCmd
+        .command('papers')
+        .description('Show discovered academic papers from arXiv')
+        .action(async () => {
+        const { getDiscoveredPapers } = await import('./discovery.js');
+        const papers = getDiscoveredPapers();
+        if (papers.length === 0) {
+            printInfo('No papers discovered yet. Run: kbot discovery start');
+            process.exit(0);
+        }
+        console.log();
+        printInfo(`${papers.length} papers found:`);
+        for (const p of papers.slice(-10)) {
+            console.log(`  ${p.title}`);
+            console.log(`    ${p.authors}`);
+            console.log(`    ${p.abstract.slice(0, 120)}...`);
+            console.log(`    ${p.url}`);
+            console.log();
+        }
+        process.exit(0);
+    });
     program
         .command('init')
         .description('Set up kbot for this project — detects stack, creates tools, writes config (60 seconds)')
@@ -606,30 +721,84 @@ async function main() {
         process.stderr.write(formatDoctorReport(report));
     });
     program
+        .command('insights')
+        .description('See yourself from kbot\'s perspective — task patterns, agent usage, efficiency, knowledge')
+        .action(async () => {
+        const { generateInsights } = await import('./introspection.js');
+        process.stderr.write(generateInsights());
+    });
+    program
+        .command('reflect')
+        .description('A narrative portrait of who you are as a builder, drawn from kbot\'s learning data')
+        .action(async () => {
+        const { generateReflection } = await import('./introspection.js');
+        process.stderr.write(generateReflection());
+    });
+    program
+        .command('compare')
+        .description('Compare your patterns to the anonymous kbot collective — see what\'s unique about you')
+        .action(async () => {
+        const { generateComparison } = await import('./introspection.js');
+        process.stderr.write(generateComparison());
+    });
+    program
+        .command('machine')
+        .description('Show full system profile — hardware, GPU, OS, dev tools, AI capabilities')
+        .option('--json', 'Output as JSON')
+        .option('--refresh', 'Force fresh probe (ignore cache)')
+        .action(async (opts) => {
+        const { probeMachine, reprobeMachine, formatMachineProfile } = await import('./machine.js');
+        const profile = opts.refresh ? await reprobeMachine() : await probeMachine();
+        if (opts.json) {
+            console.log(JSON.stringify(profile, null, 2));
+        }
+        else {
+            const chalk = (await import('chalk')).default;
+            const ACCENT = process.stdout.isTTY !== false ? chalk.hex('#A78BFA') : chalk;
+            process.stderr.write('\n  ' + ACCENT('kbot Machine') + '\n');
+            process.stderr.write(formatMachineProfile(profile));
+        }
+    });
+    const synthCmd = program
         .command('synthesis')
-        .description('Show what kbot knows — memory, learning data, patterns, and insights')
+        .description('Closed-loop intelligence compounding — bridge self-discovery and universe discovery');
+    synthCmd
+        .command('run')
+        .description('Run full synthesis cycle (all 8 operations)')
         .action(async () => {
+        const { synthesize, formatSynthesisResult } = await import('./synthesis-engine.js');
+        const chalk = (await import('chalk')).default;
+        process.stderr.write('\n' + chalk.dim('Running synthesis cycle...') + '\n\n');
+        const result = synthesize();
+        console.log(formatSynthesisResult(result));
+    });
+    synthCmd
+        .command('status')
+        .description('Show synthesis engine state and stats')
+        .action(async () => {
+        const { getSynthesisEngineStats, buildSkillMap, formatSkillMap } = await import('./synthesis-engine.js');
         const { synthesizeMemory, getInsights, getSynthesisStats } = await import('./memory-synthesis.js');
         const { getExtendedStats } = await import('./learning.js');
         const chalk = (await import('chalk')).default;
         process.stderr.write('\n');
-        // Run synthesis
-        const synthesis = synthesizeMemory();
-        const stats = getSynthesisStats();
+        // Memory synthesis (existing)
+        synthesizeMemory();
+        const memStats = getSynthesisStats();
         const learning = getExtendedStats();
         const insights = getInsights(undefined, 10);
-        console.log(chalk.bold('═══════════════════════════════════════════════════'));
-        console.log(chalk.bold(' KBOT SYNTHESIS'));
-        console.log(chalk.bold('═══════════════════════════════════════════════════'));
+        // Engine stats (new)
+        const engineStats = getSynthesisEngineStats();
+        console.log(chalk.bold('═══════════════════════════════════════════════════════'));
+        console.log(chalk.bold(' KBOT SYNTHESIS ENGINE'));
+        console.log(chalk.bold('═══════════════════════════════════════════════════════'));
         console.log('\n' + chalk.bold('## Learning Data'));
         console.log(`  Patterns:    ${learning.patternsCount}`);
         console.log(`  Solutions:   ${learning.solutionsCount}`);
         console.log(`  Knowledge:   ${learning.knowledgeCount}`);
         console.log(`  Projects:    ${learning.projectsCount}`);
-        console.log('\n' + chalk.bold('## Synthesis'));
-        console.log(`  Last run:    ${stats.lastSynthesized ?? 'never'}`);
-        console.log(`  Insights:    ${stats.insightCount}`);
-        console.log(`  Observations: ${synthesis.observationCount ?? 0}`);
+        console.log('\n' + chalk.bold('## Memory Synthesis'));
+        console.log(`  Insights:     ${memStats.insightCount}`);
+        console.log(`  Observations: ${memStats.observationCount}`);
         if (insights.length > 0) {
             console.log('\n' + chalk.bold('## Top Insights'));
             for (const insight of insights.slice(0, 8)) {
@@ -637,6 +806,16 @@ async function main() {
                 console.log(`  [${conf}%] ${insight.category ?? 'general'}: ${insight.text}`);
             }
         }
+        console.log('\n' + chalk.bold('## Closed-Loop Engine'));
+        console.log(`  Cycles:             ${engineStats.totalCycles}`);
+        console.log(`  Last cycle:         ${engineStats.lastCycleAt || 'never'}`);
+        console.log(`  Tools evaluated:    ${engineStats.toolsEvaluated} (${engineStats.toolsAdopted} adopted, ${engineStats.toolsRejected} rejected)`);
+        console.log(`  Agents trialed:     ${engineStats.agentsTrialed} (${engineStats.agentsKept} kept, ${engineStats.agentsDissolved} dissolved)`);
+        console.log(`  Papers analyzed:    ${engineStats.papersAnalyzed} (${engineStats.patternsImplemented} patterns)`);
+        console.log(`  Corrections active: ${engineStats.correctionsActive}`);
+        console.log(`  Reflections closed: ${engineStats.reflectionsClosed}`);
+        console.log(`  Patterns xferred:   ${engineStats.patternsTransferred}`);
+        console.log(`  Engagements fed:    ${engineStats.engagementsFedBack}`);
         // Discovery data if available
         const { existsSync, readFileSync } = await import('fs');
         const { join } = await import('path');
@@ -652,7 +831,84 @@ async function main() {
             }
             catch { }
         }
-        console.log('\n' + chalk.bold('═══════════════════════════════════════════════════'));
+        console.log('\n' + chalk.bold('═══════════════════════════════════════════════════════'));
+    });
+    synthCmd
+        .command('ratings')
+        .description('Display Bayesian skill map for all agents')
+        .action(async () => {
+        const { buildSkillMap, formatSkillMap } = await import('./synthesis-engine.js');
+        const map = buildSkillMap();
+        console.log('\n' + formatSkillMap(map) + '\n');
+    });
+    synthCmd
+        .command('corrections')
+        .description('Build and display active corrections for prompt injection')
+        .action(async () => {
+        const { buildActiveCorrections } = await import('./synthesis-engine.js');
+        const chalk = (await import('chalk')).default;
+        const corrections = buildActiveCorrections();
+        if (corrections.length === 0) {
+            console.log(chalk.dim('\nNo corrections extracted yet. Need more reflections or explicit corrections.\n'));
+            return;
+        }
+        console.log('\n' + chalk.bold('Active Corrections (injected into prompts):'));
+        for (const c of corrections) {
+            const icon = c.severity === 'high' ? chalk.red('!!') : c.severity === 'medium' ? chalk.yellow(' !') : chalk.dim(' -');
+            console.log(`  ${icon} ${c.rule}`);
+            console.log(chalk.dim(`     [${c.source}, ${c.occurrences}x]`));
+        }
+        console.log('');
+    });
+    synthCmd
+        .command('tools')
+        .description('Evaluate discovered tools against failure patterns')
+        .action(async () => {
+        const { consumeDiscoveredTools } = await import('./synthesis-engine.js');
+        const { join } = await import('path');
+        const chalk = (await import('chalk')).default;
+        const discDir = join(process.cwd(), '.kbot-discovery');
+        const adoptions = consumeDiscoveredTools(discDir);
+        if (adoptions.length === 0) {
+            console.log(chalk.dim('\nNo new tools to evaluate.\n'));
+            return;
+        }
+        console.log('\n' + chalk.bold(`Tool Evaluation (${adoptions.length} tools):`));
+        for (const t of adoptions) {
+            const icon = t.status === 'adopted' ? chalk.green('+') : chalk.red('×');
+            console.log(`  ${icon} ${t.name} (${t.stars}★) — ${t.reason}`);
+        }
+        console.log('');
+    });
+    synthCmd
+        .command('papers')
+        .description('Extract insights from discovered academic papers')
+        .action(async () => {
+        const { extractPaperInsights } = await import('./synthesis-engine.js');
+        const { join } = await import('path');
+        const chalk = (await import('chalk')).default;
+        const discDir = join(process.cwd(), '.kbot-discovery');
+        const insights = extractPaperInsights(discDir);
+        if (insights.length === 0) {
+            console.log(chalk.dim('\nNo new papers to analyze.\n'));
+            return;
+        }
+        console.log('\n' + chalk.bold(`Paper Insights (${insights.length} extracted):`));
+        for (const p of insights) {
+            const icon = p.status === 'proposed' ? chalk.green('→') : chalk.dim('×');
+            console.log(`  ${icon} "${p.technique}"`);
+            console.log(chalk.dim(`     From: ${p.title.slice(0, 60)}...`));
+            console.log(chalk.dim(`     Applies to: ${p.applicableTo}`));
+        }
+        console.log('');
+    });
+    // Default action (no subcommand) — run full cycle
+    synthCmd.action(async () => {
+        const { synthesize, formatSynthesisResult } = await import('./synthesis-engine.js');
+        const chalk = (await import('chalk')).default;
+        process.stderr.write('\n' + chalk.dim('Running synthesis cycle...') + '\n\n');
+        const result = synthesize();
+        console.log(formatSynthesisResult(result));
     });
     // ── Forge subcommands ──
     const forgeCmd = program
@@ -2352,11 +2608,11 @@ async function main() {
             }
         }
     }
-    // Parallel startup: register core tools (fast), gather context, check updates, cloud sync
+    // Parallel startup: register core tools (fast), gather context, probe machine, check updates, cloud sync
     const toolOpts = { computerUse: opts.computerUse };
-    const [, context, , syncMsg] = await Promise.all([
+    const [, machineProfile, , , syncMsg] = await Promise.all([
         registerCoreTools(toolOpts),
-        Promise.resolve(gatherContext()),
+        probeMachine().catch(() => null),
         // Non-blocking update check — fire and forget
         Promise.resolve().then(() => {
             try {
@@ -2368,7 +2624,10 @@ async function main() {
         }),
         // Cloud sync — pull latest learning data if available
         syncOnStartup().catch(() => null),
+        // Placeholder for alignment (5-element destructure)
+        Promise.resolve(null),
     ]);
+    const context = gatherContext(machineProfile ?? undefined);
     if (syncMsg)
         printInfo(syncMsg);
     // Determine if we're in one-shot or REPL mode
@@ -3154,6 +3413,21 @@ async function handleSlashCommand(input, opts, rl) {
         case 'help':
             printHelp();
             break;
+        case 'insights': {
+            const { generateInsights } = await import('./introspection.js');
+            process.stderr.write(generateInsights());
+            break;
+        }
+        case 'reflect': {
+            const { generateReflection } = await import('./introspection.js');
+            process.stderr.write(generateReflection());
+            break;
+        }
+        case 'compare': {
+            const { generateComparison } = await import('./introspection.js');
+            process.stderr.write(generateComparison());
+            break;
+        }
         case 'tutorial': {
             await runTutorial(rl);
             break;