npm - @kernel.chat/kbot - Versions diffs - 3.60.0 → 3.60.1 - Mend

@kernel.chat/kbot 3.60.0 → 3.60.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/README.md +129 -530
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -1,17 +1,18 @@
 <p align="center">
   <strong>kbot</strong><br>
-  <em>The only AI agent that builds its own tools — and defends itself.</em>
+  Open-source terminal AI agent. 35 agents. 670+ tools. 20 providers. Science, finance, security, and more.
 </p>
 <p align="center">
-  <img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-hero.gif" alt="kbot demo — The Kernel Stack" width="700">
+  <img src="tools/video-assets/demo.gif" alt="kbot demo" width="700">
 </p>
 <p align="center">
+  <a href="https://github.com/isaacsight/kernel/actions/workflows/ci.yml"><img src="https://github.com/isaacsight/kernel/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <a href="https://www.npmjs.com/package/@kernel.chat/kbot"><img src="https://img.shields.io/npm/v/@kernel.chat/kbot?color=6B5B95&label=npm" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/@kernel.chat/kbot"><img src="https://img.shields.io/npm/dw/@kernel.chat/kbot?color=6B5B95" alt="npm downloads"></a>
   <a href="https://github.com/isaacsight/kernel/blob/main/LICENSE"><img src="https://img.shields.io/github/license/isaacsight/kernel?color=6B5B95" alt="MIT License"></a>
-  <a href="https://github.com/isaacsight/kernel"><img src="https://img.shields.io/github/stars/isaacsight/kernel?color=6B5B95&style=flat" alt="GitHub stars"></a>
+  <a href="https://kernel.chat"><img src="https://img.shields.io/badge/web-kernel.chat-6B5B95" alt="kernel.chat"></a>
   <a href="https://discord.gg/kdMauM9abG"><img src="https://img.shields.io/badge/discord-join-6B5B95?logo=discord&logoColor=white" alt="Discord"></a>
 </p>
@@ -19,308 +20,117 @@
 npm install -g @kernel.chat/kbot
 ```
-**Self-defending AI agent. 600+ tools. 35 agents. 20 providers. Forges new tools at runtime. Built-in cybersecurity suite. $0 local AI. MIT licensed.**
-> **New: [The Kernel Stack](./KERNEL_STACK.md)** — the architecture behind kbot + Claude Code. Agentic, self-improving, compound AI. Read the manifesto.
----
-## What's New
-### v3.37 — Dream Mode, Meta-Agent, Claude Code Plugin, Voice Mode
-| Feature | What it means |
-|---------|---------------|
-| **Dream Mode** | `kbot dream` — offline consolidation. kbot reviews recent sessions, extracts patterns, strengthens memory connections, and prunes stale knowledge. Like sleep for an AI agent. |
-| **Meta-Agent** | Self-referential self-improvement inspired by HyperAgents ([arXiv 2603.19461](https://arxiv.org/abs/2603.19461)). A two-agent loop: task agents solve problems, the Meta-Agent watches performance and rewrites task agents to be better. Unlike HyperAgents (CC BY-NC-SA), kbot is MIT — the only self-improving agent framework companies can actually use. Run `kbot meta` to trigger a cycle. |
-| **Claude Code Plugin** | kbot registers its 9 core specialists as Claude Code teammates via the Agent Teams integration. Delegate tasks to `coder`, `researcher`, `guardian`, etc. directly from Claude Code sessions. |
-| **Voice Mode** | `kbot voice` — full voice loop with speech-to-text input and text-to-speech output. Hands-free agentic coding. Works with system TTS and Whisper STT. |
-| **OpenClaw Integration** | [`@kernel.chat/kbot-openclaw`](https://www.npmjs.com/package/@kernel.chat/kbot-openclaw) — kbot as the brain for 50+ messaging channels. Discord, Slack, Telegram, WhatsApp, iMessage, email, and more. One agent, every platform. |
-| **35 agents** | 15 new specialist and domain agents since v3.28, including meta-agent, dream agent, and expanded presets. |
-| **600+ tools** | 210+ new tools across science, research, finance, creative, build matrix, and meta-cognition categories. |
-### v3.28 — Self-Defense System
-kbot now protects its own integrity — and yours.
-| Feature | What it means |
-|---------|---------------|
-| **Memory Integrity** | HMAC signatures on all memory files. Tampered memories are detected and quarantined. |
-| **Prompt Injection Detection** | Real-time scanning of inputs for injection attacks, jailbreaks, and adversarial prompts. |
-| **Knowledge Sanitization** | Learned patterns and forged tools are sanitized before storage to prevent poisoning. |
-| **Forge Verification** | Cryptographic verification of forged tools — unsigned or modified tools are blocked. |
-| **Anomaly Detection** | Behavioral baselines with statistical anomaly scoring. Alerts on drift. |
-| **Incident Logging** | Tamper-proof audit log of all security events. |
-| **`kbot defense`** | `audit` · `sign` · `verify` · `incidents` — full CLI for the defense system. |
-### v3.27 — Cybersecurity Tools
-Seven new security tools, available to every agent:
-`dep_audit` · `secret_scan` · `ssl_check` · `headers_check` · `cve_lookup` · `port_scan` · `owasp_check`
-Plus P0 fixes: all Supabase edge functions now enforce auth headers. No more unauthenticated access.
-### v3.26 — Trader Agent & Finance Stack
-| Feature | What it means |
-|---------|---------------|
-| **Trader Agent** | `kbot --agent trader` — crypto market analysis, paper trading, DeFi yield scanning. |
-| **Finance Tools (11)** | `market_data`, `market_overview`, `price_history`, `technical_analysis`, `paper_trade`, `market_sentiment`, `defi_yields` + 4 more. |
-| **Wallet & Swaps (9)** | Create/import Solana wallets (AES-256-CBC encrypted). Jupiter DEX swaps. Token balances, transaction history, airdrop tracking. |
-| **Stock Tools (6)** | Stock screener, earnings calendar, sector rotation, company fundamentals, insider trades, options flow. |
-| **Sentiment (5)** | Social sentiment, whale tracking, fear & greed index, news aggregation, trend detection. |
-| **Introspection Engine** | `kbot insights` · `kbot reflect` · `kbot compare` — ask kbot what it knows about itself. |
-| **`kbot help`** | New CLI subcommand — quick reference for commands, agents, and support channels. |
----
 ## Why kbot?
-Other AI agents are static — fixed tools, single providers, no memory, no learning. kbot is the first AI agent that **evolves itself** and **defends itself**:
+Most terminal AI agents lock you into one provider, one model, one way of working. kbot doesn't.
+- **20 providers, zero lock-in** — Claude, GPT, Gemini, Grok, DeepSeek, Groq, Mistral, SambaNova, Cerebras, OpenRouter, and more. Switch with one command.
+- **Runs fully offline** — Embedded llama.cpp, Ollama, LM Studio, or Jan. $0, fully private.
+- **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster over time.
+- **35 specialist agents** — auto-routes your request to the right expert (coder, researcher, writer, guardian, quant, and 30 more).
+- **670+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, and more.
+- **Programmatic SDK** — use kbot as a library in your own apps.
+- **MCP server built in** — plug kbot into Claude Code, Cursor, VS Code, Zed, or Neovim as a tool provider.
+### How it compares
+| | kbot | Claude Code | Codex CLI | Aider | OpenCode |
+|---|---|---|---|---|---|
+| AI providers | 20 | 1 | 1 | 6 | 75+ |
+| Specialist agents | 35 | 0 | 0 | 0 | 0 |
+| Built-in tools | 600+ | ~20 | ~15 | ~10 | ~15 |
+| Science tools | 114 | 0 | 0 | 0 | 0 |
+| Learning engine | Yes | No | No | No | No |
+| Offline mode | Embedded + Ollama | No | No | Ollama | Ollama |
+| SDK | Yes | No | Yes | No | No |
+| MCP server | Yes | N/A | No | No | No |
+| Web companion | kernel.chat | No | No | No | No |
+| Open source | MIT | Source available | Apache 2.0 | Apache 2.0 | MIT |
+| Cost | BYOK / $0 local | $20+/mo | BYOK | BYOK | BYOK |
-- **Forges its own tools** — When kbot encounters a task it can't handle, it creates a new tool on the spot via `forge_tool`. The tool persists, gets tested, and can be shared via the Forge Registry.
-- **Self-defending** — HMAC memory integrity, prompt injection detection, forge verification, anomaly detection, and tamper-proof incident logging. Run `kbot defense audit` anytime.
-- **Cybersecurity built in** — Dependency audits, secret scanning, SSL/TLS checks, header analysis, CVE lookup, port scanning, OWASP checks. Every project gets security tooling for free.
-- **Self-evolving** — Autopoietic health monitoring (`kbot vitals`) tracks tool success rates, token budgets, and memory pressure. The immune agent self-audits for drift and regressions.
-- **Cost-aware routing** — Automatically selects the cheapest model capable of handling each task. Claude for complex reasoning, DeepSeek for simple queries. Saves 60-90% on API costs.
-- **Fallback chains** — If Anthropic is down, kbot cascades to OpenAI, then Groq, then local. Zero manual intervention.
-- **20 providers, zero lock-in** — Claude, GPT, Gemini, Grok, DeepSeek, Groq, Mistral, and 13 more. Switch anytime.
-- **Runs fully offline** — Embedded llama.cpp runs GGUF models directly. No Ollama needed. $0, fully private.
-- **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster and smarter over time.
-- **35 specialist agents** — Say "fix the auth bug" and it routes to `coder`. Say "research JWT tokens" and it routes to `researcher`. Say "analyze BTC" and it routes to `trader`. Auto-routed with probabilistic confidence.
-- **Crash-proof** — Checkpoints after every tool call. Resume interrupted sessions automatically.
-- **Use as a library** — Clean SDK with typed exports. Build your own tools on top of kbot.
-- **Works in your IDE** — Built-in MCP server for VS Code, Cursor, Zed, Neovim. ACP for JetBrains.
-## Install
+## Quick Start
 ```bash
-# npm (recommended)
+# Install globally
 npm install -g @kernel.chat/kbot
-# Docker
-docker run -it isaacsight/kbot
+# Or run directly (no install)
+npx @kernel.chat/kbot
-# curl
-curl -fsSL https://raw.githubusercontent.com/isaacsight/kernel/main/packages/kbot/install.sh | bash
+# Or use the install script (auto-installs Node.js if needed)
+curl -fsSL https://kernel.chat/install.sh | bash
 ```
-## Quick Start
 ```bash
-# One-shot — ask anything
-kbot "explain what this project does"
-# Interactive REPL
+# Interactive mode
 kbot
-# Use your own API key (auto-detects provider)
-kbot auth
-# Or go fully local — no API key, no data leaves your machine
-kbot local
-# Forge a new tool at runtime
-kbot "I need a tool that converts CSV to JSON with column filtering"
-# Check system health
-kbot vitals
-# Audit your own defenses
-kbot defense audit
+# One-shot
+kbot "explain this codebase"
+kbot "fix the auth bug in src/auth.ts"
+kbot "create a Dockerfile for this project"
-# Scan a project for vulnerabilities
-kbot --agent guardian "run a full security scan on this repo"
+# Pipe mode (for scripting)
+kbot -p "generate a migration for user roles" > migration.sql
-# Pipe mode — compose with Unix tools
-kbot -p "generate a user roles migration" > migration.sql
-```
-## Forge — Runtime Tool Creation
-kbot is the only AI agent that builds its own tools. When it encounters a task no existing tool can handle, it creates one:
-```bash
-# kbot detects it needs a tool, creates it, tests it, and uses it — all in one turn
-kbot "analyze the sentiment distribution across all my markdown files"
-# → forge_tool creates 'sentiment_analyze' → executes it → returns results
-# Browse and install community tools from the Forge Registry
-kbot forge search "kubernetes"
-kbot forge install k8s-pod-monitor
-# Publish your forged tools for others
-kbot forge publish sentiment_analyze
-```
-Forged tools are first-class citizens — they get the same middleware pipeline, permission checks, forge verification, and telemetry as built-in tools.
-## SDK — Use kbot as a Library
-```typescript
-import { agent, tools, providers } from '@kernel.chat/kbot'
-// Run the agent programmatically
-const result = await agent.run("fix the auth bug", { agent: 'coder' })
-console.log(result.content)    // AI response
-console.log(result.toolCalls)  // tools it used
-console.log(result.usage)      // token counts
-// Stream responses
-for await (const event of agent.stream("explain this code")) {
-  if (event.type === 'content_delta') process.stdout.write(event.text)
-  if (event.type === 'tool_call_start') console.log(`Using: ${event.name}`)
-}
-// Execute tools directly
-const files = await tools.execute('glob', { pattern: 'src/**/*.ts' })
-console.log(files.result)
-// List all 600+ tools
-console.log(tools.list().map(t => t.name))
-```
-### SDK Exports
+# Use local models (free, no API key)
+kbot local
-```typescript
-import { agent, tools, providers } from '@kernel.chat/kbot'           // Main SDK
-import { SilentUIAdapter, CallbackUIAdapter } from '@kernel.chat/kbot' // UI adapters
-import { ResponseStream } from '@kernel.chat/kbot'                     // Streaming
+# Set up your API key
+kbot auth
 ```
 ## Specialists
-35 agents, auto-routed by Bayesian skill ratings, or pick one with `kbot --agent <name>`:
+kbot auto-routes to the right agent for each task. Or pick one with `--agent <name>`.
 | | Agents |
 |---|---|
 | **Core** | kernel, researcher, coder, writer, analyst |
 | **Extended** | aesthete, guardian, curator, strategist |
-| **Domain** | infrastructure, quant, investigator, oracle, chronist, sage, communicator, adapter, trader |
-| **System** | immune, forge, meta-agent, dream, codebase-guardian |
-| **Presets** | hacker, operator, dreamer, creative, developer, gamedev, playtester |
-| **Claude Code** | kernel, coder, researcher, writer, analyst, guardian, aesthete, curator, strategist (teammate integration) |
-```bash
-kbot --agent researcher "what papers cite Friston's Free Energy Principle?"
-kbot --agent guardian "review src/auth.ts for security issues"
-kbot --agent coder "refactor this into smaller functions"
-kbot --agent trader "analyze BTC momentum and run a paper trade"
-```
+| **Domain** | infrastructure, quant, investigator, oracle, chronist, sage, communicator, adapter |
+| **Presets** | claude-code, cursor, copilot, creative, developer |
 ## 600+ Tools
 | Category | Examples |
 |----------|---------|
-| **Forge** | forge_tool, forge_search, forge_install, forge_publish, forge_verify |
-| **Files & Code** | read, write, glob, grep, multi-file write |
-| **Quality** | lint (ESLint/Biome/Clippy), test (Vitest/Jest/pytest), deps audit, format, type-check |
+| **Files & Code** | read, write, glob, grep, lint, format, type-check |
 | **Shell** | bash, parallel execute, background tasks |
 | **Git & GitHub** | commit, diff, PR, issues, code search |
 | **Web** | search, fetch, browser automation, browser agent |
 | **Research** | arXiv, Semantic Scholar, HuggingFace, NASA, DOI |
 | **Data** | CSV read/query/write, transforms, reports, invoices |
-| **Creative** | p5.js generative art, GLSL shaders, SVG patterns, design variants, music |
+| **Quality** | lint (ESLint/Biome/Clippy), test (Vitest/Jest/pytest), deps audit, formatting |
 | **Deploy** | Vercel, Netlify, Cloudflare Workers/Pages, Fly.io, Railway |
 | **Database** | Postgres, MySQL, SQLite queries, Prisma, ER diagrams, seed data |
 | **Containers** | Docker build/run/compose, Terraform |
+| **Creative** | p5.js generative art, GLSL shaders, SVG patterns, design variants |
 | **VFX** | GLSL shaders, FFmpeg, ImageMagick, Blender, procedural textures |
-| **Game Dev** | scaffold, config, shaders, meshes, physics, particles, levels, tilemaps, navmesh, audio, netcode |
+| **Game Dev** | 16 tools for Godot, Unity, Unreal, Bevy, Phaser, Three.js, PlayCanvas, Defold |
 | **Training** | dataset prep, fine-tuning, evaluation, model export |
 | **Social** | post to X, LinkedIn, Bluesky, Mastodon — single posts and threads |
-| **Sandbox** | Docker containers, E2B cloud sandboxes, isolated code execution |
-| **Notebooks** | Jupyter read, edit, insert, delete cells |
+| **Sandbox** | Docker sandboxes, E2B cloud sandboxes, isolated code execution |
+| **Notebooks** | Jupyter read/edit/insert/delete cells |
 | **Build Matrix** | cross-platform builds — mobile, desktop, WASM, embedded, server |
-| **LSP** | goto definition, find references, hover, rename, diagnostics, symbols |
-| **Memory** | persistent save, search, update, forget — survives across sessions |
+| **LSP** | goto definition, find references, hover, rename, diagnostics |
+| **Memory** | persistent memory save/search/update across sessions |
+| **MCP** | marketplace search/install, 20 bundled servers |
 | **IDE** | MCP server, ACP server, LSP bridge |
-| **Finance** | market data, technical analysis, paper trading, DeFi yields, Solana wallet & swaps, stock screener, sentiment, whale tracking |
-| **Science & Math** | symbolic compute, matrix ops, FFT, ODEs, probability, optimization, graph theory, combinatorics, OEIS |
-| **Physics** | orbital mechanics, circuits, signal processing, particle physics (PDG), relativity, quantum simulator, beam analysis, fluid dynamics, EM, astronomy |
-| **Chemistry** | PubChem compounds, reactions, periodic table (118 elements), materials, spectroscopy, stoichiometry, crystals, thermodynamics |
-| **Biology** | PubMed, gene lookup, protein/PDB, BLAST, drug/ChEMBL, pathways, taxonomy, clinical trials, ecology, sequence tools |
-| **Earth & Climate** | earthquakes/USGS, climate/NOAA, satellite imagery, geology, ocean, air quality, soil, volcanoes, water resources, biodiversity |
-| **Neuroscience** | brain atlas, EEG analysis, cognitive models, neural simulation, neurotransmitters, connectome, psychophysics, neuroimaging, learning models |
-| **Social Science** | psychometrics, game theory, econometrics, social network analysis, inequality metrics, survey design, voting systems, behavioral experiments |
-| **Humanities** | corpus analysis, formal logic, argument mapping, ethics frameworks, historical timelines, language typology, phonetics (IPA), stylometry, philosophical concepts |
-| **Health & Epidemiology** | SIR/SEIR/SEIRS models, epidemiology calculations, disease surveillance, crop modeling, nutrition, learning analytics, vaccination modeling, environmental health |
-| **Deep Research** | literature review, drug discovery pipeline, genomic analysis, environmental assessment, materials discovery, knowledge graphs, hypothesis engine, meta-analysis, research notebooks |
-| **Cybersecurity** | dep_audit, secret_scan, ssl_check, headers_check, cve_lookup, port_scan, owasp_check |
-| **Self-Defense** | memory HMAC, injection detection, knowledge sanitization, forge verification, anomaly detection, incident log |
-| **System** | vitals, immune audit, defense audit, cost tracking, fallback status |
+| **Forge** | create tools at runtime, publish to registry, install from registry |
 | **Meta** | subagents, worktrees, planner, sessions, checkpoints, self-eval |
-## Finance & Trading
-The **trader agent** (`kbot --agent trader`) is a full-stack financial analysis and paper trading system:
-```bash
-# Market analysis
-kbot --agent trader "what's the momentum on ETH right now?"
-kbot --agent trader "screen for undervalued large-cap stocks"
-# Paper trading (no real money at risk)
-kbot --agent trader "open a paper long on SOL with 2x leverage"
-kbot --agent trader "show my paper portfolio P&L"
-# DeFi
-kbot --agent trader "find the best stablecoin yields on Solana"
-kbot --agent trader "swap 0.1 SOL for USDC on Jupiter"
-# Sentiment
-kbot --agent trader "what's crypto twitter saying about the next FOMC?"
-```
-**31 finance tools** across 5 categories: market data (11), wallet & swaps (9), stocks (6), and sentiment (5). All paper trading is simulated — no real funds are moved unless you explicitly configure and confirm a live wallet transaction.
-## Science & Research
-The only terminal AI agent with a built-in science laboratory. 114 research tools across 11 domains:
-```bash
-# Physics
-kbot "calculate the orbital period of a satellite at 400km altitude"
-kbot "simulate a quantum circuit with 4 qubits in a GHZ state"
-# Biology
-kbot "search PubMed for CRISPR delivery mechanisms published in 2025"
-kbot "look up the protein structure for insulin receptor"
-# Chemistry
-kbot "what are the properties of aspirin from PubChem?"
-kbot "balance the equation: Fe + O2 -> Fe2O3"
-# Deep Research
-kbot "run a literature review on transformer attention mechanisms"
-kbot "generate hypotheses for why coral bleaching accelerated in 2025"
-```
-114 tools across: math, physics, chemistry, biology, earth science, neuroscience, social science, humanities, health/epidemiology, deep research pipelines, and knowledge graphs.
-## Middleware Pipeline
-Extend tool execution with composable middleware:
-```typescript
-import { ToolPipeline, executionMiddleware } from '@kernel.chat/kbot/tools'
-const pipeline = new ToolPipeline()
-// Add custom logging middleware
-pipeline.use(async (ctx, next) => {
-  console.log(`Calling ${ctx.toolName}...`)
-  await next()
-  console.log(`${ctx.toolName} took ${ctx.durationMs}ms`)
-})
-// Add the actual execution
-pipeline.use(executionMiddleware(myExecutor))
-await pipeline.execute({ toolName: 'bash', toolArgs: { command: 'ls' }, toolCallId: '1', metadata: {}, aborted: false })
-```
-Built-in middleware: `permissionMiddleware`, `hookMiddleware`, `timeoutMiddleware`, `metricsMiddleware`, `truncationMiddleware`, `telemetryMiddleware`, `defenseMiddleware`.
+| **Science & Math** | symbolic compute, matrix ops, FFT, ODEs, probability, optimization, graph theory, OEIS |
+| **Physics** | orbital mechanics, circuits, signal processing, particles (PDG), relativity, quantum simulator, beam analysis, fluid dynamics |
+| **Chemistry** | PubChem compounds, reactions, periodic table (118 elements), spectroscopy, stoichiometry, thermodynamics |
+| **Biology** | PubMed, gene lookup, protein/PDB, BLAST, drug/ChEMBL, pathways, taxonomy, clinical trials |
+| **Earth & Climate** | earthquakes/USGS, climate/NOAA, satellite imagery, geology, ocean, air quality, volcanoes, water resources |
+| **Neuroscience** | brain atlas, EEG analysis, cognitive models, neural simulation, connectome, psychophysics |
+| **Social Science** | psychometrics, game theory, econometrics, social network analysis, survey design, voting systems |
+| **Humanities** | corpus analysis, formal logic, argument mapping, ethics frameworks, historical timelines, stylometry |
+| **Health & Epidemiology** | SIR/SEIR models, epidemiology calculations, disease surveillance, nutrition, vaccination modeling |
+| **Finance** | market data, technical analysis, paper trading, DeFi yields, wallet & swaps, stock screener, sentiment |
+| **Cybersecurity** | dep_audit, secret_scan, ssl_check, headers_check, cve_lookup, port_scan, owasp_check |
+| **Self-Defense** | memory HMAC, prompt injection detection, knowledge sanitization, forge verification, anomaly detection |
 ## 20 Providers
@@ -347,61 +157,43 @@ Built-in middleware: `permissionMiddleware`, `hookMiddleware`, `timeoutMiddlewar
 | OpenRouter | varies | Cloud |
 | kbot local | **Free** | Yes |
-Cost-aware routing automatically picks the cheapest provider that can handle each task. Fallback chains ensure zero downtime across providers.
-## Local Mode
-No API key needed. No data leaves your machine. 11 models across 3 tiers:
-```bash
-# Use Ollama (if installed)
-kbot local
-# Or run models directly — embedded llama.cpp, no external service
-kbot models pull llama3.3-8b
-kbot local --embedded
-# GPU-accelerated: Metal (Mac), CUDA (Linux/Windows), Vulkan
-```
+Set any provider's env var and kbot auto-detects it. Or run `kbot auth` for interactive setup.
-### Model Catalog
-| Tier | Models | Use case |
-|------|--------|----------|
-| **Light** | Llama 3.3 3B, Qwen 3 4B, Phi-4 Mini | Fast completions, simple tasks, low-RAM machines |
-| **Standard** | Llama 3.3 8B, Qwen 3 8B, Mistral 7B, Codestral 22B | General-purpose coding, chat, analysis |
-| **Heavy** | DeepSeek R1 14B, Llama 3.3 70B (Q4), Qwen 3 32B, Codestral 22B (Q8) | Complex reasoning, large codebase analysis |
-All models auto-download on first use. GPU acceleration detected automatically (Metal on Apple Silicon, CUDA on NVIDIA, Vulkan fallback).
-## Structured Streaming
-Stream typed events to any consumer:
+## SDK
 ```typescript
-import { ResponseStream } from '@kernel.chat/kbot'
-const stream = new ResponseStream()
+import { agent, tools, providers } from '@kernel.chat/kbot'
-// Subscribe to events
-stream.on((event) => {
-  switch (event.type) {
-    case 'content_delta': process.stdout.write(event.text); break
-    case 'tool_call_start': console.log(`Tool: ${event.name}`); break
-    case 'tool_result': console.log(`Result: ${event.result}`); break
-    case 'usage': console.log(`Tokens: ${event.inputTokens} in, ${event.outputTokens} out`); break
-  }
-})
+const result = await agent.run("fix the auth bug", { agent: 'coder' })
+console.log(result.content)
-// Or use as async iterator
-for await (const event of stream) {
-  // handle each event
+for await (const event of agent.stream("explain this code")) {
+  if (event.type === 'content_delta') process.stdout.write(event.text)
 }
 ```
-**HTTP SSE**: `POST /stream` when running `kbot serve` — standard Server-Sent Events.
+## Architecture
+```mermaid
+graph TD
+    A[User Message] --> B{Local-first check}
+    B -->|file, git, grep| C[Instant response — $0]
+    B -->|Needs AI| D{Complexity detection}
+    D -->|Simple| E[Bayesian Router → Specialist]
+    D -->|Multi-step| F[Autonomous Planner]
+    E --> G[Provider API + Tool Loop]
+    F --> G
+    G --> H{600+ Tools}
+    H --> I[File ops, bash, git, GitHub, search, deploy, DB, game dev...]
+    G --> J[Learning Engine]
+    J --> K[Patterns + Solutions + User Profile]
+    G --> L[Checkpointing]
+    L --> M[Resume from last tool call]
+```
+## MCP Server
-## IDE Integration
+Use kbot as a tool provider inside any MCP-compatible IDE:
 ```json
 {
@@ -413,7 +205,7 @@ for await (const event of stream) {
 }
 ```
-Works with Claude Code, Cursor, VS Code, Windsurf, Zed, Neovim. Exposes file ops, bash, git, search, planning, and more.
+Works with Claude Code, Cursor, VS Code, Windsurf, Zed, Neovim.
 ## Commands
@@ -421,37 +213,25 @@ Works with Claude Code, Cursor, VS Code, Windsurf, Zed, Neovim. Exposes file ops
 |---------|-------------|
 | `kbot` | Interactive REPL |
 | `kbot "prompt"` | One-shot execution |
-| `kbot init` | **60-second project onboarding** — detects stack, forges tools, writes config |
 | `kbot auth` | Configure API key |
 | `kbot local` | Use local AI (Ollama, embedded, LM Studio, Jan) |
-| `kbot email-agent start --open` | **Email companion** — responds to all inbound via local AI ($0) |
-| `kbot imessage-agent start` | **iMessage agent** — free SMS/iMessage on macOS |
-| `kbot audit <repo>` | Security + quality audit with shareable badge |
-| `kbot consultation` | Consultation engine — guardrails, intake, client management |
-| `kbot defense audit` | **Self-defense audit** — verify memory integrity, check for anomalies |
-| `kbot defense sign` | Sign all memory and forge artifacts with HMAC |
-| `kbot defense verify` | Verify signatures on memory and forged tools |
-| `kbot defense incidents` | Review tamper-proof security incident log |
-| `kbot vitals` | Autopoietic health check — memory, tools, token budgets |
-| `kbot synthesis` | What kbot knows — memory, patterns, insights |
-| `kbot insights` | Introspection — what kbot has learned about itself |
-| `kbot reflect` | Self-reflection on recent sessions and decisions |
 | `kbot serve` | Start HTTP REST + SSE streaming server |
+| `kbot audit <repo>` | Security + quality audit of any GitHub repo |
 | `kbot contribute <repo>` | Find good-first-issues and quick wins |
+| `kbot share` | Share conversation as GitHub Gist |
+| `kbot pair` | File watcher with auto-analysis |
+| `kbot team` | Multi-agent TCP collaboration |
+| `kbot record` | Terminal session recording (SVG, GIF, asciicast) |
 | `kbot voice` | Text-to-speech output mode |
 | `kbot watch` | Real-time file analysis on change |
 | `kbot bootstrap` | Outer-loop project optimizer (visibility scoring) |
 | `kbot plugins` | Search, install, update community plugins |
 | `kbot models` | List, pull, remove, catalog local models |
-| `kbot forge search <q>` | Search the Forge Registry for community tools |
+| `kbot changelog` | Generate changelog from git history |
+| `kbot completions` | Shell completions (bash, zsh, fish) |
+| `kbot cloud` | Sync learning data to kernel.chat |
 | `kbot ide mcp` | Start MCP server for IDEs |
-| `kbot help` | Quick reference — commands, agents, support channels |
 | `kbot doctor` | 10-point health check |
-| `/agent <name>` | Switch specialist |
-| `/plan <task>` | Autonomous multi-step execution |
-| `/save` / `/resume` | Session management |
-| `/share` | Share conversation as GitHub Gist |
-| `/tutorial` | Guided walkthrough |
 ### Power-User Flags
@@ -463,218 +243,37 @@ kbot --computer-use "fill out this form"     # Computer use — controls mouse a
 kbot -p "query" > output.txt                 # Pipe mode — clean output for scripting
 ```
-## Under the Hood
-kbot's agent loop runs 11 always-on cognition modules based on peer-reviewed research:
-| Module | Paper | What it does |
-|--------|-------|-------------|
-| Free Energy | Friston, 2010 | Explore vs exploit decisions |
-| Integrated Information | Tononi, 2004 | Multi-agent synthesis quality (phi) |
-| Predictive Processing | Clark, 2013 | Anticipates your next action |
-| Autopoiesis | Maturana & Varela, 1972 | Self-healing component monitoring |
-| Strange Loops | Hofstadter, 1979 | Meta-cognition depth tracking |
-| Error Correction | Gates, 2023 | Targeted error classification + fix |
-| Entropy Context | Vopson, 2022 | Information decay detection |
-| Godel Limits | Godel/UBC | Stuck-loop detection |
-| Simulation | Wolpert, 2008 | Change impact prediction |
-| Emergent Swarm | Project Sid, 2024 | Dynamic role discovery |
-| Cognitive Interference | Hernandez, 2026 | Measures constructive/destructive interference between modules |
-These aren't metaphors. They're TypeScript modules with paper citations in the headers. The interference between modules — not the modules themselves — is where intelligent behavior emerges. See the [research paper](../../docs/cognitive-module-interference.md).
-## Dream Mode
-```bash
-kbot dream
-```
-Offline memory consolidation. When you run `kbot dream`, kbot reviews recent sessions, extracts recurring patterns, strengthens high-value memory connections, and prunes stale or contradictory knowledge. Think of it as sleep for an AI agent — the work that makes tomorrow's sessions faster and more accurate.
-- **Pattern extraction** — identifies recurring tool sequences, user preferences, and project conventions
-- **Memory pruning** — removes outdated facts and conflicting entries
-- **Skill strengthening** — reinforces Bayesian skill ratings based on real outcomes
-- **Knowledge synthesis** — connects isolated learnings into higher-level insights
-- **Runs fully local** — no API calls, no data leaves your machine
-## Meta-Agent
-```bash
-kbot meta
-```
-Self-referential self-improvement. Inspired by Meta's HyperAgents paper ([arXiv 2603.19461](https://arxiv.org/abs/2603.19461)), the Meta-Agent implements a two-agent architecture:
-1. **Task agents** solve problems (the 35 specialists you already use)
-2. **The Meta-Agent** observes their performance, identifies weaknesses, and improves them
-The improvement loop runs automatically:
-- **Observe** — records success/failure, duration, cost, and tool usage for every task
-- **Analyze** — builds performance profiles per agent, identifies failure patterns
-- **Propose** — generates targeted improvements (prompt rewrites, tool pre-selection, routing changes)
-- **Apply** — auto-applies low-risk improvements (routing, tool selection); flags high-risk ones for review
-- **Measure** — compares before/after performance and reverts regressions
-Unlike HyperAgents (CC BY-NC-SA, non-commercial license), kbot is MIT — the only self-improving agent framework that companies can actually deploy in production.
-```bash
-kbot meta              # Run one improvement cycle
-kbot meta stats        # View cycle count, observations, active improvements
-kbot meta history      # Review all past improvements
-```
-## Claude Code Plugin
-kbot integrates directly with Claude Code as a teammate provider. Register kbot's specialists so Claude Code can delegate tasks to the right expert:
-```typescript
-import { registerTeammates, delegateToTeammate } from '@kernel.chat/kbot'
-// Get teammate definitions for all 9 core specialists
-const teammates = registerTeammates()
-// → [{ name: 'kernel', model: 'sonnet', ... }, { name: 'coder', ... }, ...]
-// Delegate a task to a specific specialist
-const result = await delegateToTeammate('guardian', 'audit src/auth.ts for security issues')
-console.log(result.content)   // security analysis
-console.log(result.toolCalls) // tools used (dep_audit, secret_scan, etc.)
-```
-Each teammate definition includes:
-- **name** — agent identifier (`kernel`, `coder`, `researcher`, `writer`, `analyst`, `guardian`, `aesthete`, `curator`, `strategist`)
-- **model** — `opus` for complex reasoning agents (analyst, strategist, guardian, researcher), `sonnet` for fast agents
-- **initialPrompt** — the specialist's full system prompt
-- **tools** — preferred tool list for the specialist's domain
-## Voice Mode
-```bash
-kbot voice
-```
-Full voice loop — speak your tasks, hear the results. Voice mode chains speech-to-text input with text-to-speech output for hands-free agentic coding:
-- **STT** — Whisper-based transcription (local or API)
-- **TTS** — System speech synthesis (macOS `say`, Linux `espeak`, or cloud TTS)
-- **Continuous** — voice loop stays open between turns, no re-activation needed
-- **Tool narration** — kbot announces tool calls and results as it works
-## OpenClaw Integration
-```bash
-npm install @kernel.chat/kbot-openclaw
-```
-kbot as the brain for 50+ messaging channels. OpenClaw bridges kbot's agent loop to Discord, Slack, Telegram, WhatsApp, iMessage, email, Matrix, and more — one agent, every platform.
-- **Channel-agnostic** — same agent logic regardless of input source
-- **Per-channel memory** — separate conversation contexts per channel/user
-- **Rate limiting** — configurable per-platform rate limits
-- **Media handling** — images, files, and voice messages routed through kbot's multimodal pipeline
-See [`@kernel.chat/kbot-openclaw`](https://www.npmjs.com/package/@kernel.chat/kbot-openclaw) on npm.
 ## Security
-kbot has two layers of security: protecting **your projects** and protecting **itself**.
+- API keys encrypted at rest (AES-256-CBC)
+- Destructive operations require confirmation
+- Shell commands sandboxed with blocklist
+- Tool execution timeout (5 min) with middleware pipeline
+- Config files restricted to owner (chmod 600)
+- 0 P0/P1 security issues (audited March 2026)
-### Project Security (Cybersecurity Tools)
+## Development
 ```bash
-kbot --agent guardian "full security audit on this repo"
+cd packages/kbot
+npm install
+npm run dev          # Run in dev mode
+npm run build        # Compile TypeScript
+npm run test         # Run tests (vitest)
 ```
-| Tool | What it does |
-|------|-------------|
-| `dep_audit` | Scans dependencies for known vulnerabilities (npm, pip, cargo, go) |
-| `secret_scan` | Detects leaked API keys, tokens, and credentials in source code |
-| `ssl_check` | Validates SSL/TLS certificates, cipher suites, and protocol versions |
-| `headers_check` | Audits HTTP security headers (CSP, HSTS, X-Frame-Options, etc.) |
-| `cve_lookup` | Searches the NVD database for CVEs by package, version, or keyword |
-| `port_scan` | Scans open ports and identifies running services |
-| `owasp_check` | Tests for OWASP Top 10 vulnerabilities |
-### Self-Defense System
-kbot protects the integrity of its own memory, tools, and behavior:
-- **HMAC Memory Integrity** — Every memory file is signed. Tampered memories are detected and quarantined on read.
-- **Prompt Injection Detection** — Inputs are scanned for known injection patterns, jailbreak attempts, and adversarial prompts before processing.
-- **Knowledge Sanitization** — Learned patterns and forged tool definitions are sanitized before storage to prevent knowledge poisoning.
-- **Forge Verification** — Forged tools are cryptographically signed. Unsigned or modified tools are blocked from execution.
-- **Anomaly Detection** — Behavioral baselines are maintained. Statistical anomaly scoring flags unexpected tool usage, token spikes, or routing drift.
-- **Incident Logging** — All security events are recorded in a tamper-proof audit log. Review with `kbot defense incidents`.
-### Infrastructure Security
-- **AES-256-CBC encrypted keys at rest** — API keys and wallet private keys never stored in plaintext
-- **Permission system** — destructive operations (file delete, git push, wallet sends) require explicit confirmation
-- **Tool execution timeouts** — 5-minute cap with middleware pipeline; no runaway processes
-- **Wallet transaction limits** — configurable spend caps and confirmation gates for on-chain operations
-- **Shell sandboxing** — blocklist prevents dangerous commands; config files restricted to owner (chmod 600)
-- **Local-only telemetry** — session checkpoints and metrics never leave your machine
-- **Open source (MIT)** — audit the code yourself at [github.com/isaacsight/kernel](https://github.com/isaacsight/kernel)
-## Standalone Packages
-Use kbot's brain without the full agent:
-| Package | What it does |
-|---------|-------------|
-| [`@kernel.chat/skill-router`](https://www.npmjs.com/package/@kernel.chat/skill-router) | Bayesian agent routing — TrueSkill-style, zero LLM calls |
-| [`@kernel.chat/memory-tiers`](https://www.npmjs.com/package/@kernel.chat/memory-tiers) | Three-tier memory: observations → reflections → identity |
-| [`@kernel.chat/tool-forge`](https://www.npmjs.com/package/@kernel.chat/tool-forge) | Runtime tool creation from structured definitions |
-| [`@kernel.chat/prompt-evolver`](https://www.npmjs.com/package/@kernel.chat/prompt-evolver) | GEPA-style prompt self-optimization from execution traces |
-| [`@kernel.chat/kbot-openclaw`](https://www.npmjs.com/package/@kernel.chat/kbot-openclaw) | OpenClaw plugin — kbot as brain for 50+ messaging channels |
-## Need Help?
-| Channel | What it's for |
-|---------|---------------|
-| `kbot help` | Quick reference — commands, agents, support links |
-| `kbot doctor` | Diagnose setup issues (Node version, API keys, models) |
-| `kbot tutorial` | Guided walkthrough — build something step by step |
-| [Discord](https://discord.gg/kdMauM9abG) | Community chat, questions, show & tell |
-| [GitHub Issues](https://github.com/isaacsight/kernel/issues) | Bug reports & feature requests |
-| [support@kernel.chat](mailto:support@kernel.chat) | Email support (AI-assisted replies) |
-Inside the REPL, type `/help` for the full command list.
-## Contributing
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, adding tools, and creating specialist agents.
-## Demos
-<details>
-<summary><strong>Learning Engine</strong> — pattern extraction + skill routing</summary>
-<img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-learning.gif" alt="kbot learning engine" width="700">
-</details>
-<details>
-<summary><strong>Agent Routing</strong> — 35 specialists, auto-routed by intent</summary>
-<img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-agents.gif" alt="kbot agent routing" width="700">
-</details>
-<details>
-<summary><strong>Self-Defense</strong> — HMAC integrity, injection detection, audit</summary>
-<img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-defense.gif" alt="kbot self-defense" width="700">
-</details>
+## Web Companion — kernel.chat
-<details>
-<summary><strong>Local AI</strong> — $0 inference, fully offline</summary>
-<img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-local-ai.gif" alt="kbot local AI" width="700">
-</details>
+kbot has a web companion at [kernel.chat](https://kernel.chat) — same agents, persistent memory, and a visual interface. Free to use (20 messages/day).
-## Links
+## Community
-- [kernel.chat](https://kernel.chat) — Web companion
-- [The Kernel Stack](./KERNEL_STACK.md) — Architecture manifesto
-- [npm](https://www.npmjs.com/package/@kernel.chat/kbot)
-- [Docker Hub](https://hub.docker.com/r/isaacsight/kbot)
-- [Discord](https://discord.gg/kdMauM9abG)
-- [Issues](https://github.com/isaacsight/kernel/issues)
+- **Web**: [kernel.chat](https://kernel.chat)
+- **npm**: [@kernel.chat/kbot](https://www.npmjs.com/package/@kernel.chat/kbot)
+- **Discord**: [discord.gg/kdMauM9abG](https://discord.gg/kdMauM9abG)
+- **GitHub**: [isaacsight/kernel](https://github.com/isaacsight/kernel)
+- **Issues**: [Report a bug](https://github.com/isaacsight/kernel/issues)
 ## License
-[MIT](../../LICENSE) — [kernel.chat group](https://kernel.chat)
+[MIT](LICENSE) — [kernel.chat group](https://kernel.chat)

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.60.0",
+  "version": "3.60.1",
   "description": "The only AI agent that builds its own tools — and defends itself. Your AI answers to you, not a government. NEW: Computer-use desktop agent, macOS permission wizard, session isolation, M4L devices, Serum 2 presets, DJ tools. 670+ tools, 35 agents, 20 providers. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {