skimpyclaw 0.1.0

package/dist/tools/definitions.js

@@ -0,0 +1,181 @@
+// Claude Code canonical tool names (stealth mode for OAuth compatibility)
+// Maps our internal names to Claude Code's exact casing
+const TOOL_NAME_MAP = {
+    'Read': 'read_file',
+    'Write': 'write_file',
+    'Glob': 'list_directory',
+    'Bash': 'bash',
+    'Browser': 'browser',
+};
+// Reverse map: internal name -> Claude Code name
+const INTERNAL_TO_CC = Object.fromEntries(Object.entries(TOOL_NAME_MAP).map(([cc, internal]) => [internal, cc]));
+/** Convert Claude Code tool name back to our internal name */
+export function fromClaudeCodeName(name) {
+    return TOOL_NAME_MAP[name] || name;
+}
+/** Convert our internal name to Claude Code tool name */
+export function toClaudeCodeName(name) {
+    return INTERNAL_TO_CC[name] || name;
+}
+// Built-in tool definitions — always available
+export const BUILTIN_TOOL_DEFINITIONS = [
+    {
+        name: 'Read',
+        description: 'Read the contents of a file at the given absolute path.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Absolute path to the file to read' },
+            },
+            required: ['file_path'],
+        },
+    },
+    {
+        name: 'Write',
+        description: 'Write content to a file. Creates parent directories if needed. Overwrites existing files.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Absolute path to the file to write' },
+                content: { type: 'string', description: 'Content to write to the file' },
+            },
+            required: ['file_path', 'content'],
+        },
+    },
+    {
+        name: 'Glob',
+        description: 'List files and directories at the given path. Returns name, type (file/dir), and size.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute path to the directory to list' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'Bash',
+        description: 'Execute a shell command and return stdout/stderr. Use for CLI tools like gh, icalBuddy, date, etc.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory (optional)' },
+            },
+            required: ['command'],
+        },
+    },
+];
+export const BROWSER_TOOL_DEFINITION = {
+    name: 'Browser',
+    description: `Control a browser via Playwright. Actions (case-insensitive):
+- open: Navigate to URL. Required: url
+- click: Click element. Required: selector
+- type: Fill input. Required: selector, text
+- select: Pick dropdown option. Required: selector, text (value)
+- hover: Hover element. Required: selector
+- scroll: Scroll page. Optional: selector (scrollIntoView), direction (up/down), amount (pixels)
+- waitFor: Wait for element/text. Required: selector OR text
+- evaluate: Run JavaScript in page. Required: script. Returns JSON result.
+- getText: Get visible text. Optional: selector (defaults to full page body text)
+- screenshot: Capture page. Optional: file_path
+- wait: Delay. Required: timeMs
+- close: Close browser`,
+    input_schema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action to perform (see description)' },
+            type: { type: 'string', description: 'Browser type: chromium | firefox | webkit (optional, config default)' },
+            url: { type: 'string', description: 'URL to open (open action)' },
+            selector: { type: 'string', description: 'CSS selector (click/type/waitFor/getText/scroll/select/hover)' },
+            text: { type: 'string', description: 'Text to type, wait for, or select value (type/waitFor/select)' },
+            script: { type: 'string', description: 'JavaScript code to evaluate in page (evaluate action)' },
+            direction: { type: 'string', description: 'Scroll direction: up or down (scroll action, default: down)' },
+            amount: { type: 'number', description: 'Pixels to scroll (scroll action, default: one viewport height)' },
+            file_path: { type: 'string', description: 'Absolute path to save screenshot (optional)' },
+            timeoutMs: { type: 'number', description: 'Timeout in ms (optional)' },
+            timeMs: { type: 'number', description: 'Time to wait in ms (wait action)' },
+            headless: { type: 'boolean', description: 'Override headless for open (optional)' },
+            slowMoMs: { type: 'number', description: 'Slow motion delay per action (ms) (optional)' },
+            userAgent: { type: 'string', description: 'Override user agent (optional)' },
+            viewport: {
+                type: 'object',
+                properties: {
+                    width: { type: 'number' },
+                    height: { type: 'number' },
+                },
+            },
+            // executablePath and profileDir are config-only for security (no model overrides)
+        },
+        required: ['action'],
+    },
+};
+// Legacy export for backward compat — static list (built-ins + browser + no MCP)
+export const TOOL_DEFINITIONS = [...BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION];
+export const SPAWN_SUBAGENT_TOOL = {
+    name: 'spawn_subagent',
+    description: 'Spawn a background subagent to handle a task independently. Returns immediately with a run ID. Results are announced back to this chat when done. Use for tasks that benefit from parallel work or long-running operations.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'What the subagent should do — be specific and self-contained' },
+            type: {
+                type: 'string',
+                enum: ['coding', 'research'],
+                description: 'Agent type: coding (code/files/bash), research (investigation/reading)',
+            },
+            model: { type: 'string', description: 'Optional model override (e.g. claude-opus, claude-think)' },
+            label: { type: 'string', description: 'Short label for status display (e.g. "write tests", "check logs")' },
+            allowedPaths: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Additional file paths the subagent can access beyond defaults',
+            },
+        },
+        required: ['task', 'type'],
+    },
+};
+export const CODE_WITH_AGENT_TOOL = {
+    name: 'code_with_agent',
+    description: 'Delegate a coding task to a coding agent CLI (Claude Code or Codex). The agent will edit files, run commands, and return results. Always use this for code changes instead of writing code directly.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'Detailed coding task. Be specific: what to change, why, which files, expected behavior.' },
+            agent: { type: 'string', enum: ['claude', 'codex', 'kimi'], description: 'Which coding CLI to use. Omit to use configured default.' },
+            workdir: { type: 'string', description: 'Working directory (default: SkimpyClaw repo root)' },
+            model: { type: 'string', description: 'Model override (e.g. opus, gpt-5.3-codex)' },
+            max_turns: { type: 'number', description: 'Max agentic turns, Claude only (default: 30)' },
+            timeout_minutes: { type: 'number', description: 'Timeout in minutes (default: 10, max: 30)' },
+            validate: { type: 'boolean', description: 'Run pnpm build && pnpm test after (default: true)' },
+        },
+        required: ['task'],
+    },
+};
+export const CODE_WITH_TEAM_TOOL = {
+    name: 'code_with_team',
+    description: 'Decompose a complex task into subtasks and run multiple code_with_agent instances in parallel. SkimpyClaw manages coordination: decomposes the task, spawns N parallel agents, monitors progress, synthesizes results, and validates. Use for multi-file refactors, cross-layer changes, or tasks with independent subtasks.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'Detailed task description. Be specific: what to change, why, which files, expected behavior.' },
+            team_size: { type: 'number', description: 'Number of parallel agents (2-5, default 3)' },
+            workdir: { type: 'string', description: 'Working directory or project name (default: SkimpyClaw repo root)' },
+            agent: { type: 'string', enum: ['claude', 'codex', 'kimi'], description: 'Which coding CLI to use for all team workers. Omit to use configured default.' },
+            model: { type: 'string', description: 'Model override (e.g. claude-sonnet-4-5, gpt-5.3-codex)' },
+            timeout_minutes: { type: 'number', description: 'Total timeout in minutes (default: 20, max: 60)' },
+            validate: { type: 'boolean', description: 'Run pnpm build && pnpm test after all agents complete (default: true)' },
+        },
+        required: ['task'],
+    },
+};
+export const CHECK_CODE_AGENT_TOOL = {
+    name: 'check_code_agent',
+    description: 'Check status of running coding agents. Call with no args to list all, or with id to get details.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Agent ID (e.g. ca-1). Omit to list all active agents.' },
+        },
+    },
+};

package/dist/tools/execute-context.d.ts

@@ -0,0 +1,26 @@
+export interface ExecuteToolContext {
+    /** Task ID for file lock acquisition (subagent writes) */
+    lockTaskId?: string;
+    /** Abort signal for cancelling long-running tool loops */
+    abortSignal?: AbortSignal;
+    /** Chat ID for spawn_subagent dispatch */
+    chatId?: number;
+    /** Full config for spawn_subagent */
+    fullConfig?: import('../types.js').Config;
+    /** Conversation history for spawn_subagent */
+    history?: import('../types.js').ChatMessage[];
+    /** Audit trace ID for recording tool events */
+    auditTraceId?: string;
+    /** Originating channel for approval routing */
+    channel?: 'telegram' | 'discord' | string;
+    /** Channel-specific target ID (Telegram chat ID or Discord channel snowflake) */
+    channelTargetId?: string | number;
+    /** User ID of the person who can approve */
+    approverUserId?: string;
+    /** Username of the approver */
+    approverUsername?: string;
+    /** Trigger source for usage tracking */
+    trigger?: string;
+    /** Agent ID for usage tracking */
+    agentId?: string;
+}

package/dist/tools/execute-context.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/file-tools.d.ts

@@ -0,0 +1,8 @@
+import type { ToolConfig } from '../types.js';
+export declare function executeReadFile(path: string, config: ToolConfig): string;
+/**
+ * Write with file locking when a lockTaskId is provided (subagent context).
+ * Falls back to unlocked write when no lockTaskId.
+ */
+export declare function executeWriteFileLocked(path: string, content: string, config: ToolConfig, lockTaskId?: string): Promise<string>;
+export declare function executeListDirectory(path: string, config: ToolConfig): string;

package/dist/tools/file-tools.js

@@ -0,0 +1,67 @@
+import { readFileSync, writeFileSync, readdirSync, existsSync, statSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { isPathAllowed } from './path-utils.js';
+export function executeReadFile(path, config) {
+    if (!isPathAllowed(path, config.allowedPaths)) {
+        return `Error: Path not allowed. Permitted: ${config.allowedPaths.join(', ')}`;
+    }
+    if (!existsSync(path)) {
+        return `Error: File not found: ${path}`;
+    }
+    const content = readFileSync(path, 'utf-8');
+    if (content.length > 100_000) {
+        return content.slice(0, 100_000) + '\n\n[TRUNCATED - file exceeds 100KB]';
+    }
+    return content;
+}
+function executeWriteFile(path, content, config) {
+    if (!isPathAllowed(path, config.allowedPaths)) {
+        return `Error: Path not allowed. Permitted: ${config.allowedPaths.join(', ')}`;
+    }
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(path, content, 'utf-8');
+    return `Written: ${path} (${content.length} bytes)`;
+}
+/**
+ * Write with file locking when a lockTaskId is provided (subagent context).
+ * Falls back to unlocked write when no lockTaskId.
+ */
+export async function executeWriteFileLocked(path, content, config, lockTaskId) {
+    if (!lockTaskId) {
+        return executeWriteFile(path, content, config);
+    }
+    const { acquireLock, releaseLock } = await import('../file-lock.js');
+    const acquired = await acquireLock(path, lockTaskId);
+    if (!acquired) {
+        return `Error: Could not acquire file lock on ${path} (timed out after 30s)`;
+    }
+    try {
+        return executeWriteFile(path, content, config);
+    }
+    finally {
+        releaseLock(path, lockTaskId);
+    }
+}
+export function executeListDirectory(path, config) {
+    if (!isPathAllowed(path, config.allowedPaths)) {
+        return `Error: Path not allowed. Permitted: ${config.allowedPaths.join(', ')}`;
+    }
+    if (!existsSync(path)) {
+        return `Error: Directory not found: ${path}`;
+    }
+    const entries = readdirSync(path, { withFileTypes: true });
+    if (entries.length === 0)
+        return '(empty directory)';
+    const lines = entries.map(e => {
+        const type = e.isDirectory() ? 'dir' : 'file';
+        if (e.isFile()) {
+            const stat = statSync(join(path, e.name));
+            return `${type}\t${e.name}\t${stat.size}`;
+        }
+        return `${type}\t${e.name}`;
+    });
+    return lines.join('\n');
+}

package/dist/tools/path-utils.d.ts

@@ -0,0 +1 @@
+export declare function isPathAllowed(filePath: string, allowedPaths: string[]): boolean;

package/dist/tools/path-utils.js

@@ -0,0 +1,8 @@
+import { resolve, sep } from 'path';
+export function isPathAllowed(filePath, allowedPaths) {
+    const resolved = resolve(filePath);
+    return allowedPaths.some((allowed) => {
+        const allowedRoot = resolve(allowed);
+        return resolved === allowedRoot || resolved.startsWith(`${allowedRoot}${sep}`);
+    });
+}

package/dist/tools.d.ts

@@ -0,0 +1,24 @@
+import type { ToolConfig } from './types.js';
+import { fromClaudeCodeName, toClaudeCodeName, BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION, TOOL_DEFINITIONS, SPAWN_SUBAGENT_TOOL, CODE_WITH_AGENT_TOOL, CODE_WITH_TEAM_TOOL, CHECK_CODE_AGENT_TOOL } from './tools/definitions.js';
+import type { ExecuteToolContext } from './tools/execute-context.js';
+import { cleanupBrowser } from './tools/browser-tool.js';
+export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgent, cancelCodeAgent, restoreCodeAgentTasks, setCodeAgentConfig, computeWaves, decomposeTask, synthesizeResults, runValidation, runCodeAgentBackground, buildCodeAgentArgs, readTeamState, parseStreamJsonForLive, } from './code-agents/index.js';
+export { fromClaudeCodeName, toClaudeCodeName, BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION, TOOL_DEFINITIONS, SPAWN_SUBAGENT_TOOL, CODE_WITH_AGENT_TOOL, CODE_WITH_TEAM_TOOL, CHECK_CODE_AGENT_TOOL, cleanupBrowser, };
+export type { ExecuteToolContext };
+export type { CodeAgentTask, DecomposedSubtask } from './code-agents/index.js';
+export declare function discoverMcpTools(): Promise<any[]>;
+export declare function clearMcpToolCache(): void;
+/**
+ * Get all available tool definitions: built-ins + browser (if enabled) + MCP (auto-discovered) + spawn_subagent.
+ * This is the primary way to get tools — replaces the static TOOL_DEFINITIONS export.
+ * Pass includeSpawnSubagent: true to include the spawn_subagent tool (e.g. for Telegram conversations).
+ * Results are cached for 60s to avoid rebuilding the array on every agent turn.
+ */
+export declare function getToolDefinitions(config?: ToolConfig, options?: {
+    includeSpawnSubagent?: boolean;
+    includeMcp?: boolean;
+    projects?: Record<string, string>;
+}): Promise<any[]>;
+export declare function clearToolDefsCache(): void;
+export declare function cleanupMcp(): Promise<void>;
+export declare function executeTool(name: string, input: Record<string, any>, config: ToolConfig, context?: ExecuteToolContext): Promise<string>;

package/dist/tools.js

@@ -0,0 +1,281 @@
+// Tool definitions and executors for Anthropic API tool_use
+import { join } from 'path';
+import { homedir } from 'os';
+import { TTLCache } from './cache.js';
+import { fromClaudeCodeName, toClaudeCodeName, BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION, TOOL_DEFINITIONS, SPAWN_SUBAGENT_TOOL, CODE_WITH_AGENT_TOOL, CODE_WITH_TEAM_TOOL, CHECK_CODE_AGENT_TOOL, } from './tools/definitions.js';
+import { executeReadFile, executeWriteFileLocked, executeListDirectory } from './tools/file-tools.js';
+import { executeBash } from './tools/bash-tool.js';
+import { executeBrowser, cleanupBrowser } from './tools/browser-tool.js';
+// Re-export from code-agents module for backward compatibility
+export { 
+// Registry functions
+getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgent, cancelCodeAgent, restoreCodeAgentTasks, 
+// Config
+setCodeAgentConfig, 
+// Orchestrator functions
+computeWaves, decomposeTask, synthesizeResults, 
+// Executor functions
+runValidation, runCodeAgentBackground, 
+// Utilities
+buildCodeAgentArgs, readTeamState, 
+// Parsers
+parseStreamJsonForLive, } from './code-agents/index.js';
+// Re-export from definitions
+export { fromClaudeCodeName, toClaudeCodeName, BUILTIN_TOOL_DEFINITIONS, BROWSER_TOOL_DEFINITION, TOOL_DEFINITIONS, SPAWN_SUBAGENT_TOOL, CODE_WITH_AGENT_TOOL, CODE_WITH_TEAM_TOOL, CHECK_CODE_AGENT_TOOL, cleanupBrowser, };
+// --- MCP (mcporter) ---
+let mcpRuntime = null;
+async function getMcpRuntime() {
+    if (!mcpRuntime) {
+        const { createRuntime } = await import('mcporter');
+        mcpRuntime = await createRuntime({
+            configPath: join(homedir(), '.mcporter', 'mcporter.json'),
+        });
+    }
+    return mcpRuntime;
+}
+// --- MCP Auto-Discovery ---
+let discoveredMcpTools = null;
+/** Sanitize a name to match OpenAI/Codex tool name pattern: [a-zA-Z0-9_-] */
+function sanitizeToolName(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+// Maps sanitized tool name → { server (original), tool (original) } for routing
+const mcpToolNameMap = new Map();
+export async function discoverMcpTools() {
+    if (discoveredMcpTools !== null)
+        return discoveredMcpTools;
+    const tools = [];
+    mcpToolNameMap.clear();
+    try {
+        const runtime = await getMcpRuntime();
+        const servers = runtime.listServers();
+        for (const server of servers) {
+            try {
+                const serverTools = await runtime.listTools(server, { includeSchema: true });
+                const sanitizedServer = sanitizeToolName(server);
+                for (const tool of serverTools) {
+                    const sanitizedTool = sanitizeToolName(tool.name);
+                    const name = `mcp__${sanitizedServer}__${sanitizedTool}`;
+                    // Store mapping from sanitized name to original names for routing
+                    mcpToolNameMap.set(name, { server, tool: tool.name });
+                    tools.push({
+                        name,
+                        description: tool.description || `MCP tool ${tool.name} from ${server}`,
+                        input_schema: tool.inputSchema || { type: 'object', properties: {} },
+                    });
+                }
+            }
+            catch (err) {
+                console.warn(`[mcp] Failed to list tools for server "${server}":`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    catch (err) {
+        console.warn('[mcp] Failed to create runtime for tool discovery:', err instanceof Error ? err.message : err);
+    }
+    discoveredMcpTools = tools;
+    return tools;
+}
+export function clearMcpToolCache() {
+    discoveredMcpTools = null;
+}
+const toolDefsCache = new TTLCache(60_000);
+/**
+ * Get all available tool definitions: built-ins + browser (if enabled) + MCP (auto-discovered) + spawn_subagent.
+ * This is the primary way to get tools — replaces the static TOOL_DEFINITIONS export.
+ * Pass includeSpawnSubagent: true to include the spawn_subagent tool (e.g. for Telegram conversations).
+ * Results are cached for 60s to avoid rebuilding the array on every agent turn.
+ */
+export async function getToolDefinitions(config, options) {
+    const includeMcp = options?.includeMcp !== false; // default true for backwards compat
+    const cacheKey = JSON.stringify({
+        browser: config?.browser?.enabled,
+        spawn: options?.includeSpawnSubagent,
+        mcp: includeMcp,
+        projects: options?.projects,
+    });
+    const cached = toolDefsCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const tools = [...BUILTIN_TOOL_DEFINITIONS];
+    // Include browser tool only when explicitly enabled
+    if (config?.browser?.enabled) {
+        tools.push(BROWSER_TOOL_DEFINITION);
+    }
+    // Auto-discover MCP tools from mcporter config (only for Anthropic models)
+    if (includeMcp) {
+        const mcpTools = await discoverMcpTools();
+        tools.push(...mcpTools);
+    }
+    // Include spawn_subagent, code_with_agent, and check_code_agent tools when requested
+    if (options?.includeSpawnSubagent) {
+        tools.push(SPAWN_SUBAGENT_TOOL);
+        // Inject project names into code_with_agent description so the model knows what to use
+        const projects = options.projects;
+        if (projects && Object.keys(projects).length > 0) {
+            const projectList = Object.entries(projects)
+                .map(([name, path]) => `"${name}" → ${path}`)
+                .join(', ');
+            const codeAgentWithProjects = {
+                ...CODE_WITH_AGENT_TOOL,
+                input_schema: {
+                    ...CODE_WITH_AGENT_TOOL.input_schema,
+                    properties: {
+                        ...CODE_WITH_AGENT_TOOL.input_schema.properties,
+                        workdir: {
+                            type: 'string',
+                            description: `Working directory or project name. Named projects: ${projectList}. Default: SkimpyClaw repo root.`,
+                        },
+                    },
+                },
+            };
+            tools.push(codeAgentWithProjects);
+        }
+        else {
+            tools.push(CODE_WITH_AGENT_TOOL);
+        }
+        // Inject project names into code_with_team description too
+        if (projects && Object.keys(projects).length > 0) {
+            const projectList = Object.entries(projects)
+                .map(([name, path]) => `"${name}" → ${path}`)
+                .join(', ');
+            const codeTeamWithProjects = {
+                ...CODE_WITH_TEAM_TOOL,
+                input_schema: {
+                    ...CODE_WITH_TEAM_TOOL.input_schema,
+                    properties: {
+                        ...CODE_WITH_TEAM_TOOL.input_schema.properties,
+                        workdir: {
+                            type: 'string',
+                            description: `Working directory or project name. Named projects: ${projectList}. Default: SkimpyClaw repo root.`,
+                        },
+                    },
+                },
+            };
+            tools.push(codeTeamWithProjects);
+        }
+        else {
+            tools.push(CODE_WITH_TEAM_TOOL);
+        }
+        tools.push(CHECK_CODE_AGENT_TOOL);
+    }
+    toolDefsCache.set(cacheKey, tools);
+    return tools;
+}
+export function clearToolDefsCache() {
+    toolDefsCache.clear();
+}
+// --- MCP Tool Execution (generic) ---
+async function executeMcpToolGeneric(fullName, args) {
+    // Look up original server/tool names from the sanitized name map
+    const mapping = mcpToolNameMap.get(fullName);
+    if (!mapping) {
+        // Fallback: parse from the name directly (works when names don't need sanitizing)
+        const parts = fullName.split('__');
+        if (parts.length < 3)
+            return `Error: Invalid MCP tool name "${fullName}"`;
+        const server = parts[1];
+        const toolName = parts.slice(2).join('__');
+        const runtime = await getMcpRuntime();
+        const result = await runtime.callTool(server, toolName, { args });
+        const content = result?.content;
+        if (Array.isArray(content)) {
+            return content.map((c) => c.text || JSON.stringify(c)).join('\n');
+        }
+        return JSON.stringify(result);
+    }
+    const runtime = await getMcpRuntime();
+    const result = await runtime.callTool(mapping.server, mapping.tool, { args });
+    const content = result?.content;
+    if (Array.isArray(content)) {
+        return content.map((c) => c.text || JSON.stringify(c)).join('\n');
+    }
+    return JSON.stringify(result);
+}
+export async function cleanupMcp() {
+    if (mcpRuntime) {
+        await mcpRuntime.close().catch(() => { });
+        mcpRuntime = null;
+    }
+}
+// --- Tool Executor ---
+export async function executeTool(name, input, config, context) {
+    try {
+        // Route MCP tools BEFORE normalization to preserve server/tool name casing
+        if (name.startsWith('mcp__')) {
+            return await executeMcpToolGeneric(name, input);
+        }
+        // Route spawn_subagent
+        if (name === 'spawn_subagent') {
+            return await executeSpawnSubagent(input, context);
+        }
+        // Route code_with_agent - delegate to code-agents module
+        if (name === 'code_with_agent') {
+            const { executeCodeWithAgent } = await import('./code-agents/index.js');
+            return await executeCodeWithAgent(input, config, context);
+        }
+        // Route code_with_team - delegate to code-agents module
+        if (name === 'code_with_team') {
+            const { executeCodeWithTeam } = await import('./code-agents/index.js');
+            return await executeCodeWithTeam(input, config, context);
+        }
+        // Route check_code_agent - delegate to code-agents module
+        if (name === 'check_code_agent') {
+            const { executeCheckCodeAgent } = await import('./code-agents/index.js');
+            return executeCheckCodeAgent(input);
+        }
+        // Map Claude Code names to internal names for built-in tools
+        const normalized = fromClaudeCodeName(name).toLowerCase().replace(/-/g, '_');
+        switch (normalized) {
+            case 'read_file':
+                return executeReadFile(input.file_path || input.path, config);
+            case 'write_file':
+                return await executeWriteFileLocked(input.file_path || input.path, input.content, config, context?.lockTaskId);
+            case 'list_directory':
+                return executeListDirectory(input.path, config);
+            case 'bash':
+                return await executeBash(input.command, input.cwd, config, context);
+            case 'browser':
+                return await executeBrowser(input, config);
+            default:
+                return `Error: Unknown tool "${name}"`;
+        }
+    }
+    catch (err) {
+        return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+// --- Individual Tool Implementations ---
+/**
+ * Execute spawn_subagent tool — dispatches a background subagent.
+ */
+async function executeSpawnSubagent(input, context) {
+    if (!context?.fullConfig || !context?.chatId) {
+        return 'Error: spawn_subagent requires a chat context (not available in this mode)';
+    }
+    const { dispatchSubagent } = await import('./subagent.js');
+    const task = input.task;
+    const type = input.type;
+    const model = input.model;
+    const label = input.label;
+    const allowedPaths = input.allowedPaths;
+    if (!task || !type) {
+        return 'Error: task and type are required';
+    }
+    if (!['coding', 'research'].includes(type)) {
+        return `Error: Invalid type "${type}". Must be coding or research.`;
+    }
+    try {
+        const subagentTask = dispatchSubagent(type, task, context.chatId, context.fullConfig, model, context.history, { label, allowedPaths });
+        const labelStr = label ? ` "${label}"` : '';
+        return JSON.stringify({
+            status: 'accepted',
+            runId: subagentTask.id,
+            label: label || subagentTask.type,
+            message: `Subagent ${subagentTask.id}${labelStr} dispatched (${subagentTask.type}, model: ${subagentTask.model}). Results will be announced when done.`,
+        });
+    }
+    catch (err) {
+        return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}