@kernel.chat/kbot 3.74.0 → 3.83.0

package/README.md

@@ -16,6 +16,7 @@
   <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://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>
+  <a href="https://glama.ai/mcp/servers/isaacsight/kernel"><img src="https://glama.ai/mcp/servers/isaacsight/kernel/badges/score.svg" alt="kbot MCP server"></a>
 </p>
 
 ```bash
@@ -305,6 +306,8 @@ graph TD
 
 ## MCP Server
 
+[![kbot MCP server](https://glama.ai/mcp/servers/isaacsight/kernel/badges/card.svg)](https://glama.ai/mcp/servers/isaacsight/kernel)
+
 Use kbot as a tool provider inside any MCP-compatible IDE:
 
 ```json
@@ -317,6 +320,12 @@ Use kbot as a tool provider inside any MCP-compatible IDE:
 }
 ```
 
+Or run the MCP server via Docker:
+
+```bash
+docker run -i --rm kernelchat/kbot ide mcp
+```
+
 Works with Claude Code, Cursor, VS Code, Windsurf, Zed, Neovim.
 
 ## Commands

package/dist/cli.js

@@ -1960,6 +1960,40 @@ async function main() {
             printInfo(`Or pull all: ${missing.map(m => `ollama pull ${m.name}`).join(' && ')}`);
         }
     });
+    program
+        .command('stream [action]')
+        .description('Multi-platform livestream to Twitch, Rumble, and Kick simultaneously')
+        .option('-p, --platforms <list>', 'Comma-separated: twitch,rumble,kick or "all"', 'all')
+        .option('-s, --source <src>', 'Video source: screen, webcam, test, or file path', 'screen')
+        .option('-r, --resolution <res>', 'Output resolution', '1920x1080')
+        .option('-b, --bitrate <kbps>', 'Video bitrate in kbps', '4500')
+        .action(async (action, opts) => {
+        const { ensureLazyToolsLoaded, executeTool: execTool } = await import('./tools/index.js');
+        await ensureLazyToolsLoaded();
+        const cmd = (action || 'status').toLowerCase();
+        if (cmd === 'start' || cmd === 'go' || cmd === 'live') {
+            const result = await execTool({
+                id: `stream_${Date.now()}`, name: 'stream_start',
+                arguments: { platforms: opts?.platforms, source: opts?.source, resolution: opts?.resolution, bitrate: opts?.bitrate },
+            });
+            process.stderr.write(result.result + '\n');
+        }
+        else if (cmd === 'stop' || cmd === 'end') {
+            const result = await execTool({ id: `stream_${Date.now()}`, name: 'stream_stop', arguments: {} });
+            process.stderr.write(result.result + '\n');
+        }
+        else if (cmd === 'status') {
+            const result = await execTool({ id: `stream_${Date.now()}`, name: 'stream_status', arguments: {} });
+            process.stderr.write(result.result + '\n');
+        }
+        else if (cmd === 'setup') {
+            const result = await execTool({ id: `stream_${Date.now()}`, name: 'stream_setup', arguments: { platform: 'all' } });
+            process.stderr.write(result.result + '\n');
+        }
+        else {
+            process.stderr.write(`Unknown stream action: ${cmd}\nUsage: kbot stream [start|stop|status|setup]\n`);
+        }
+    });
     program
         .command('serve')
         .description('Start HTTP/HTTPS server — expose all tools for kernel.chat, Claude Cowork, or any client')

package/dist/ide/mcp-server.js

@@ -16,6 +16,21 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { initBridge, chat, executeCommand, getTools, getStatus, getAgents, getMemory, getSessions, getContext, getFileDiagnostics, remember, setAgent, } from './bridge.js';
 import { ResponseStream } from '../streaming.js';
 import { formatDiagnostics } from './lsp-bridge.js';
+import { createRequire } from 'node:module';
+const __require = createRequire(import.meta.url);
+const PKG_VERSION = __require('../../package.json').version;
+/** Sanitize error messages to prevent leaking internal paths, keys, or URLs */
+function sanitizeError(err) {
+    if (err instanceof Error) {
+        return err.message
+            .replace(/Bearer\s+\S+/gi, 'Bearer [REDACTED]')
+            .replace(/apikey\s+\S+/gi, 'apikey [REDACTED]')
+            .replace(/https?:\/\/[^\s]+/g, '[URL]')
+            .replace(/\/Users\/[^\s]+/g, '[PATH]')
+            .replace(/\/home\/[^\s]+/g, '[PATH]');
+    }
+    return 'An unexpected error occurred';
+}
 /**
  * Start the MCP server on stdio.
  * This is the entry point called by `kbot ide mcp`.
@@ -25,7 +40,7 @@ export async function startMcpServer(config = {}) {
     await initBridge(config);
     const server = new Server({
         name: 'kbot',
-        version: '2.0.0',
+        version: PKG_VERSION,
     }, {
         capabilities: {
             tools: {},
@@ -39,90 +54,90 @@ export async function startMcpServer(config = {}) {
         const staticTools = [
             {
                 name: 'kbot_chat',
-                description: 'Send a message to kbot and get an agent response. Supports 22 specialist agents with automatic routing.',
+                description: 'Send a natural language message to kbot and receive a specialist agent response. kbot automatically routes to the best-fit agent (coder, researcher, writer, analyst, guardian, or 30 others) based on message intent, or you can force a specific agent via the agent parameter. Use this tool when you need AI-powered assistance for coding, research, writing, analysis, security review, or any general task. Do not use this for direct file operations (use kbot_read_file, kbot_edit_file, kbot_write_file instead) or shell commands (use kbot_bash instead). Each call is stateless -- conversation history is not preserved between calls. Returns the agent response text, plus optional thinking traces and tool-use results if the agent invoked sub-tools.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        message: { type: 'string', description: 'The message to send to kbot' },
-                        agent: { type: 'string', description: 'Force a specific agent (kernel, researcher, coder, writer, analyst, etc.). Defaults to auto-routing.' },
+                        message: { type: 'string', description: 'The natural language message or task description for kbot. Must be a non-empty string. Be specific about what you need -- e.g., "refactor this function to use async/await" rather than "fix this".' },
+                        agent: { type: 'string', description: 'Force a specific specialist agent by ID. Available agents: "coder" (programming), "researcher" (research and fact-finding), "writer" (content creation), "analyst" (strategy and evaluation), "guardian" (security), "quant" (data analysis), "aesthete" (design), "infrastructure" (DevOps), and 27 more. Omit to let kbot auto-route based on message content.' },
                     },
                     required: ['message'],
                 },
             },
             {
                 name: 'kbot_edit_file',
-                description: 'Edit a file using search/replace. Finds old_string and replaces with new_string.',
+                description: 'Edit an existing file by finding and replacing a specific text occurrence. Locates the first exact match of old_string in the file and replaces it with new_string. Use this tool for targeted, surgical edits to existing files -- prefer this over kbot_write_file when you only need to change part of a file. Do not use this for creating new files (use kbot_write_file instead). Always call kbot_read_file first to verify the exact text you want to replace. Side effects: modifies the file on disk. Fails with an error if old_string is not found or the file does not exist.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        path: { type: 'string', description: 'File path to edit' },
-                        old_string: { type: 'string', description: 'Text to find' },
-                        new_string: { type: 'string', description: 'Replacement text' },
+                        path: { type: 'string', description: 'Absolute or relative file path to edit. The file must already exist.' },
+                        old_string: { type: 'string', description: 'Exact text to find in the file. Must match precisely including all whitespace and indentation. Copy the text from kbot_read_file output to ensure accuracy.' },
+                        new_string: { type: 'string', description: 'Replacement text to insert where old_string was found. Can be an empty string to delete the matched text.' },
                     },
                     required: ['path', 'old_string', 'new_string'],
                 },
             },
             {
                 name: 'kbot_write_file',
-                description: 'Create or overwrite a file with content.',
+                description: 'Create a new file or completely overwrite an existing file with the provided content. Creates parent directories automatically if they do not exist. Use this tool when creating new files from scratch. Do not use this for partial edits to existing files (use kbot_edit_file instead, which preserves the rest of the file). If the target file already exists, call kbot_read_file first to avoid unintentional data loss. Side effects: writes to disk, may create directories.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        path: { type: 'string', description: 'File path' },
-                        content: { type: 'string', description: 'File content' },
+                        path: { type: 'string', description: 'Absolute or relative file path to write. Parent directories are created automatically if missing.' },
+                        content: { type: 'string', description: 'Complete file content to write. This replaces the entire file -- include all content, not just changes.' },
                     },
                     required: ['path', 'content'],
                 },
             },
             {
                 name: 'kbot_read_file',
-                description: 'Read the contents of a file.',
+                description: 'Read and return the full text contents of a file from the local filesystem. Use this tool to inspect source code, configuration files, documentation, or data files before making edits. Always call this before kbot_edit_file to verify the exact text you want to replace. Do not use this for binary files (images, compiled artifacts). Read-only operation with no side effects. Returns an error message if the file does not exist or is not readable.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        path: { type: 'string', description: 'File path to read' },
+                        path: { type: 'string', description: 'Absolute or relative file path to read. Supports any text-based file format.' },
                     },
                     required: ['path'],
                 },
             },
             {
                 name: 'kbot_bash',
-                description: 'Run a shell command and return the output.',
+                description: 'Execute a shell command in the project working directory and return combined stdout and stderr output. Use this tool for build commands (npm run build), git operations (git status, git diff), package management (npm install), running tests (npm test), and system checks (which, ls, cat). Do not use this for file reading (use kbot_read_file) or file writing (use kbot_write_file) -- those tools are safer and more reliable. Destructive commands (rm -rf, git reset --hard) require user confirmation when --safe mode is enabled. Side effects: depends on the command executed. Commands exceeding the timeout are terminated with SIGTERM.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        command: { type: 'string', description: 'Shell command to execute' },
-                        timeout: { type: 'number', description: 'Timeout in milliseconds (default: 30000)' },
+                        command: { type: 'string', description: 'Shell command to execute. Avoid commands requiring interactive input (like vim, nano, or prompts). Pipe-friendly commands work best.' },
+                        timeout: { type: 'number', description: 'Maximum execution time in milliseconds before the command is killed. Default: 30000 (30 seconds). Maximum: 300000 (5 minutes). Increase for long-running builds or tests.' },
                     },
                     required: ['command'],
                 },
             },
             {
                 name: 'kbot_search',
-                description: 'Search the web for information.',
+                description: 'Search the web for current information and return summarized results. Use this tool when you need real-time data, recent events, up-to-date documentation, or answers not available in local files. Do not use this for searching the local project codebase (use kbot_grep or kbot_glob instead) or for GitHub-specific searches (use kbot_github instead). Read-only operation with no side effects. Requires a search provider to be configured via kbot auth.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        query: { type: 'string', description: 'Search query' },
+                        query: { type: 'string', description: 'Web search query string. Be specific and include relevant keywords for better results -- e.g., "React 19 useActionState migration guide" rather than "React hooks".' },
                     },
                     required: ['query'],
                 },
             },
             {
                 name: 'kbot_github',
-                description: 'Search GitHub repositories and code.',
+                description: 'Search GitHub for repositories, code snippets, or issues/PRs matching a query. Use this tool to find libraries, reference implementations, open issues, or code examples across public GitHub repositories. Do not use this for web searches (use kbot_search instead) or local file searches (use kbot_grep instead). Read-only operation with no side effects. Returns structured results with repository names, descriptions, star counts, and URLs.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        query: { type: 'string', description: 'GitHub search query' },
-                        type: { type: 'string', description: 'Search type: repositories, code, issues' },
+                        query: { type: 'string', description: 'GitHub search query. Supports GitHub search qualifiers like "language:typescript", "stars:>100", "topic:mcp-server". Example: "mcp server language:typescript stars:>50".' },
+                        type: { type: 'string', description: 'What to search for. "repositories" searches repo names and descriptions. "code" searches file contents across repos. "issues" searches issue and PR titles and bodies. Default: "repositories".' },
                     },
                     required: ['query'],
                 },
             },
             {
                 name: 'kbot_status',
-                description: 'Get kbot status including agent info, learning stats, and session count.',
+                description: 'Retrieve kbot runtime status as a JSON object. Returns the active specialist agent, learning engine statistics (patterns, solutions, knowledge entries, total messages processed), session count, and registered tool count. Use this tool to verify kbot is properly configured, check which agent is active, or monitor learning progress. Do not use this for project-specific status (use kbot_bash with "git status" instead). Read-only operation with no side effects.',
                 inputSchema: {
                     type: 'object',
                     properties: {},
@@ -130,68 +145,68 @@ export async function startMcpServer(config = {}) {
             },
             {
                 name: 'kbot_agent',
-                description: 'Switch the active kbot agent or list available agents.',
+                description: 'Switch the active specialist agent for subsequent kbot_chat calls, or list all available agents when called without arguments. Use this tool to optimize responses by selecting the right specialist -- e.g., switch to "guardian" before a security review, or "researcher" before a deep-dive investigation. Do not use this if you only need to route a single message (pass the agent parameter to kbot_chat instead). Side effects: when agent ID is provided, changes the active agent for all future kbot_chat calls in this session.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        agent: { type: 'string', description: 'Agent ID to switch to. Omit to list available agents.' },
+                        agent: { type: 'string', description: 'Agent ID to activate. Examples: "coder", "researcher", "writer", "analyst", "guardian", "quant", "infrastructure", "aesthete". Omit this parameter entirely to list all 35 available agents with descriptions.' },
                     },
                 },
             },
             {
                 name: 'kbot_remember',
-                description: 'Teach kbot a fact that persists across sessions.',
+                description: 'Store a fact in kbot persistent memory that persists across sessions and restarts. Use this tool to teach kbot project-specific conventions (e.g., "This project uses pnpm, not npm"), user preferences (e.g., "User prefers functional React components"), or domain knowledge that should inform future agent responses. Do not use this for temporary notes or session-specific context. Side effects: writes to the learning database on disk at ~/.kbot/. Facts are automatically surfaced to agents as context in future sessions.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        fact: { type: 'string', description: 'The fact to remember' },
+                        fact: { type: 'string', description: 'The fact, convention, or knowledge to persist. Be specific and declarative -- e.g., "This project uses Vitest for testing, not Jest" rather than "testing stuff".' },
                     },
                     required: ['fact'],
                 },
             },
             {
                 name: 'kbot_diagnostics',
-                description: 'Get LSP diagnostics (type errors, warnings) for a file.',
+                description: 'Retrieve TypeScript/JavaScript diagnostics (type errors, warnings, lint issues) for a specific source file via the kbot LSP bridge. Use this tool to check for type errors before committing changes, to verify that a fix resolved a type issue, or to understand compilation errors. Do not use this for runtime errors (use kbot_bash to run the code instead) or for non-TypeScript files. Read-only operation with no side effects. Returns formatted diagnostic messages with file path, line number, column, severity level, and error message.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        path: { type: 'string', description: 'File path to check' },
+                        path: { type: 'string', description: 'Absolute or relative path to the TypeScript or JavaScript file to check for diagnostics.' },
                     },
                     required: ['path'],
                 },
             },
             {
                 name: 'kbot_plan',
-                description: 'Generate and execute an autonomous plan for a complex task.',
+                description: 'Generate and optionally execute an autonomous multi-step plan for a complex task. The planner analyzes the task, breaks it into ordered subtasks, selects appropriate tools for each step, executes them sequentially, and self-corrects on failures with retries. Use this tool for complex multi-file refactors, full-stack feature implementations, research-then-implement workflows, or any task requiring coordination of multiple tools. Do not use this for simple single-step operations (use the specific tool directly). Side effects: depends on plan steps -- may read/write files, run shell commands, make API calls. Set auto_approve=false to review the generated plan before any execution begins.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        task: { type: 'string', description: 'The complex task to plan and execute' },
-                        auto_approve: { type: 'boolean', description: 'Auto-approve (default: false)' },
+                        task: { type: 'string', description: 'Detailed description of the complex task to plan and execute. More context leads to better plans -- include relevant file paths, expected outcomes, and constraints.' },
+                        auto_approve: { type: 'boolean', description: 'Controls whether plan steps execute automatically. false (default): generates the plan and returns it for review without executing. true: generates and immediately executes all steps without confirmation.' },
                     },
                     required: ['task'],
                 },
             },
             {
                 name: 'kbot_glob',
-                description: 'Find files matching a glob pattern.',
+                description: 'Find files matching a glob pattern in the project directory tree. Use this tool to discover files by name pattern before reading or editing them -- e.g., find all test files, all TypeScript files in a directory, or locate a specific config file. Do not use this for searching file contents (use kbot_grep instead). Read-only operation with no side effects. Returns a list of matching absolute file paths sorted by most recently modified first.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        pattern: { type: 'string', description: 'Glob pattern (e.g., "**/*.ts")' },
-                        path: { type: 'string', description: 'Base directory (default: cwd)' },
+                        pattern: { type: 'string', description: 'Glob pattern to match against file paths. Supports ** for recursive directory matching, * for single-level wildcards, and {a,b} for alternatives. Examples: "**/*.ts" (all TypeScript files), "src/**/*.test.tsx" (all test files in src), "*.json" (JSON files in current directory).' },
+                        path: { type: 'string', description: 'Base directory to start searching from. Default: current working directory. Use an absolute path for predictable results.' },
                     },
                     required: ['pattern'],
                 },
             },
             {
                 name: 'kbot_grep',
-                description: 'Search file contents with regex.',
+                description: 'Search file contents for lines matching a regular expression pattern. Use this tool to find function definitions, string references, import statements, TODO comments, or any text pattern across the project codebase. Do not use this for finding files by name (use kbot_glob instead) or for web searches (use kbot_search instead). Read-only operation with no side effects. Returns matching lines with file path, line number, and the matched line content.',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        pattern: { type: 'string', description: 'Regex pattern' },
-                        path: { type: 'string', description: 'File or directory to search' },
+                        pattern: { type: 'string', description: 'Regular expression pattern to search for in file contents. Supports full regex syntax. Examples: "function\\s+\\w+" (function declarations), "TODO|FIXME|HACK" (code annotations), "import.*from \'react\'" (React imports).' },
+                        path: { type: 'string', description: 'File or directory to search in. When a directory is given, searches recursively through all text files. Default: current working directory.' },
                     },
                     required: ['pattern'],
                 },
@@ -372,7 +387,7 @@ export async function startMcpServer(config = {}) {
             return {
                 content: [{
                         type: 'text',
-                        text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                        text: `Error: ${sanitizeError(err)}`,
                     }],
                 isError: true,
             };
@@ -452,11 +467,11 @@ export async function startMcpServer(config = {}) {
     server.setRequestHandler(ListPromptsRequestSchema, async () => {
         return {
             prompts: [
-                { name: 'explain_code', description: 'Explain what code does', arguments: [{ name: 'code', required: true, description: 'Code to explain' }] },
-                { name: 'review_code', description: 'Review code for bugs and improvements', arguments: [{ name: 'code', required: true, description: 'Code to review' }] },
-                { name: 'fix_error', description: 'Fix a code error', arguments: [{ name: 'error', required: true, description: 'Error message' }, { name: 'code', required: false, description: 'Relevant code' }] },
-                { name: 'generate_tests', description: 'Generate tests for code', arguments: [{ name: 'code', required: true, description: 'Code to test' }] },
-                { name: 'refactor', description: 'Suggest refactoring improvements', arguments: [{ name: 'code', required: true, description: 'Code to refactor' }] },
+                { name: 'explain_code', description: 'Generate a detailed explanation of what a code snippet does, including its purpose, control flow, key operations, and return values. Use this when you need to understand unfamiliar code.', arguments: [{ name: 'code', required: true, description: 'The source code snippet to explain. Can be any programming language.' }] },
+                { name: 'review_code', description: 'Perform a code review identifying bugs, security vulnerabilities, performance issues, and improvement opportunities. Returns categorized findings with severity levels and suggested fixes.', arguments: [{ name: 'code', required: true, description: 'The source code to review. Include enough surrounding context for accurate analysis.' }] },
+                { name: 'fix_error', description: 'Diagnose and fix a code error given an error message and optionally the relevant source code. Returns the corrected code with an explanation of what caused the error and how the fix resolves it.', arguments: [{ name: 'error', required: true, description: 'The full error message, stack trace, or diagnostic output.' }, { name: 'code', required: false, description: 'The source code that produced the error. Include the function or block containing the error for best results.' }] },
+                { name: 'generate_tests', description: 'Generate comprehensive test cases for a code snippet, covering happy paths, edge cases, error conditions, and boundary values. Outputs test code in the appropriate testing framework for the language.', arguments: [{ name: 'code', required: true, description: 'The source code to generate tests for. Include type signatures and function documentation for better test coverage.' }] },
+                { name: 'refactor', description: 'Analyze code and suggest refactoring improvements for readability, maintainability, performance, and adherence to best practices. Returns the refactored code with explanations for each change.', arguments: [{ name: 'code', required: true, description: 'The source code to refactor. Include the complete function or module for context-aware suggestions.' }] },
             ],
         };
     });

package/dist/tools/index.js

@@ -314,6 +314,9 @@ const LAZY_MODULE_IMPORTS = [
     { path: './mobile-automation.js', registerFn: 'registerMobileAutomationTools' },
     { path: './iphone.js', registerFn: 'registerIPhoneTools' },
     { path: './ghost.js', registerFn: 'registerGhostTools' },
+    { path: './streaming.js', registerFn: 'registerStreamingTools' },
+    { path: './stream-character.js', registerFn: 'registerStreamCharacterTools' },
+    { path: './stream-renderer.js', registerFn: 'registerStreamRendererTools' },
 ];
 /** Track whether lazy tools have been registered */
 let lazyToolsRegistered = false;

package/dist/tools/render-engine.d.ts

@@ -0,0 +1,158 @@
+import type { CanvasRenderingContext2D } from 'canvas';
+export interface Light {
+    x: number;
+    y: number;
+    radius: number;
+    color: string;
+    intensity: number;
+    flicker?: boolean;
+}
+/**
+ * Render dynamic lighting over the scene.
+ * First draws a dark ambient overlay, then additively blends each light source.
+ */
+export declare function renderLighting(ctx: CanvasRenderingContext2D, lights: Light[], width: number, height: number, ambientLight: number): void;
+/**
+ * Get ambient light level for a given time of day.
+ */
+export declare function getAmbientForTime(timeOfDay: string): number;
+/**
+ * Build default light sources for the kbot stream character.
+ */
+export declare function buildCharacterLights(robotX: number, robotY: number, scale: number, moodColor: string, frame: number, hasLightning: boolean, worldItems?: Array<{
+    x: number;
+    y: number;
+    emoji: string;
+    name: string;
+}>): Light[];
+export interface BloomSpot {
+    x: number;
+    y: number;
+    radius: number;
+    color: string;
+}
+/**
+ * Render soft glowing halos around bright elements.
+ */
+export declare function renderBloom(ctx: CanvasRenderingContext2D, brightSpots: BloomSpot[]): void;
+/**
+ * Build default bloom spots for the kbot character.
+ */
+export declare function buildCharacterBloom(robotX: number, robotY: number, scale: number, moodColor: string, frame: number): BloomSpot[];
+export interface Particle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    life: number;
+    maxLife: number;
+    size: number;
+    color: string;
+    type: 'spark' | 'fire' | 'magic' | 'electricity' | 'trail' | 'smoke' | 'aura';
+    trail?: Array<{
+        x: number;
+        y: number;
+    }>;
+    gravity?: number;
+    cx?: number;
+    cy?: number;
+    orbitRadius?: number;
+    orbitPhase?: number;
+    startX?: number;
+    startY?: number;
+    endX?: number;
+    endY?: number;
+    midpoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    lastMidpointFrame?: number;
+    pulsePhase?: number;
+}
+/**
+ * Create particles of a given type at a position.
+ */
+export declare function createParticleEmitter(type: Particle['type'], x: number, y: number, count: number): Particle[];
+/**
+ * Tick all particles: apply physics, age, return survivors.
+ */
+export declare function tickParticles(particles: Particle[]): Particle[];
+/**
+ * Render all particles to the canvas.
+ */
+export declare function renderParticles(ctx: CanvasRenderingContext2D, particles: Particle[]): void;
+/**
+ * Render a full procedural sky based on time of day, weather, and frame.
+ */
+export declare function renderSky(ctx: CanvasRenderingContext2D, width: number, height: number, timeOfDay: string, weather: string, frame: number, dividerX?: number): void;
+export interface ParallaxLayer {
+    type: 'far' | 'mid' | 'near';
+    factor: number;
+    draw: (ctx: CanvasRenderingContext2D, offsetX: number, frame: number) => void;
+}
+/**
+ * Build parallax layers for a given biome.
+ */
+export declare function buildParallaxLayers(biome: string, dividerX: number): ParallaxLayer[];
+/**
+ * Render parallax layers relative to robot position.
+ */
+export declare function renderParallaxLayers(ctx: CanvasRenderingContext2D, layers: ParallaxLayer[], robotX: number, frame: number): void;
+export interface GrowingPlant {
+    x: number;
+    y: number;
+    type: 'tree' | 'flower' | 'mushroom' | 'crystal';
+    growthStage: number;
+    maxHeight: number;
+    color: string;
+}
+/**
+ * Tick and render growing vegetation.
+ */
+export declare function tickGrowingPlants(plants: GrowingPlant[]): void;
+export declare function renderGrowingPlants(ctx: CanvasRenderingContext2D, plants: GrowingPlant[]): void;
+/**
+ * Render animated water with multiple sine waves, reflections, and foam.
+ */
+export declare function renderAnimatedWater(ctx: CanvasRenderingContext2D, dividerX: number, frame: number): void;
+/**
+ * Render lava with organic flow patterns and popping bubbles.
+ */
+export declare function renderLavaFlow(ctx: CanvasRenderingContext2D, dividerX: number, frame: number): void;
+/**
+ * Draw AAA character effects: eye glow bleed, power-up aura, walk trail, etc.
+ */
+export declare function drawCharacterEffects(ctx: CanvasRenderingContext2D, x: number, y: number, scale: number, mood: string, frame: number, isExecutingTool: boolean, walkSpeed: number, moodColor: string): void;
+/**
+ * Track mood changes and return chromatic aberration offset if transitioning.
+ * Returns {active, framesLeft} — caller draws character 3x with RGB offsets.
+ */
+export declare function checkMoodTransition(mood: string, moodColor: string): {
+    active: boolean;
+    framesLeft: number;
+};
+/**
+ * Trigger a white damage flash for 2 frames.
+ */
+export declare function triggerDamageFlash(): void;
+/**
+ * Render damage flash overlay on the character.
+ * Returns true if flash is active (caller should skip normal character rendering logic).
+ */
+export declare function renderDamageFlash(ctx: CanvasRenderingContext2D, x: number, y: number, scale: number): boolean;
+export interface PostProcessOptions {
+    bloom: boolean;
+    filmGrain: boolean;
+    vignette: boolean;
+    scanlines: boolean;
+    focusPulse?: {
+        x: number;
+        y: number;
+        radius: number;
+    };
+}
+/**
+ * Apply screen-space post-processing effects.
+ */
+export declare function renderPostProcessing(ctx: CanvasRenderingContext2D, width: number, height: number, frame: number, options: PostProcessOptions): void;
+//# sourceMappingURL=render-engine.d.ts.map