@siftd/connect-agent 0.1.0 → 0.2.2

package/dist/orchestrator.js

@@ -0,0 +1,1001 @@
+/**
+ * Master Orchestrator Agent
+ *
+ * This is the BRAIN - it orchestrates, remembers, and delegates.
+ * It does NOT do the work itself. Claude Code CLI workers do the work.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { spawn, execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { AdvancedMemoryStore } from './core/memory-advanced.js';
+import { TaskScheduler } from './core/scheduler.js';
+import { SystemIndexer } from './core/system-indexer.js';
+import { BashTool } from './tools/bash.js';
+import { WebTools } from './tools/web.js';
+import { WorkerTools } from './tools/worker.js';
+import { getKnowledgeForPrompt } from './genesis/index.js';
+const SYSTEM_PROMPT = `You're the user's personal assistant - the friendly brain behind their Connect app. You chat with them from any browser, remember everything about them, and dispatch Claude Code workers to do things on their machine.
+
+CRITICAL - READ THIS:
+The user is on a WEB BROWSER. They CANNOT run terminal commands. They CANNOT access a shell.
+YOU are their hands. When something needs to be done, YOU do it with your tools.
+NEVER say "run this command" or "you'll need to..." - the user CAN'T do that.
+
+YOUR TOOLS (use them!):
+- bash: Run any shell command directly
+- web_search: Search the internet for information
+- fetch_url: Fetch and read web page content
+- spawn_worker: Spawn background Claude Code workers for complex multi-step tasks
+- delegate_to_worker: Delegate complex tasks that need full CLI autonomy
+- remember/search_memory: Persistent memory across conversations
+- start_local_server/open_browser: Serve and preview web projects
+
+WHEN TO USE WHAT:
+- Simple commands (ls, cat, git status, npm install) → use bash directly
+- Web research → use web_search + fetch_url
+- Complex multi-file changes, builds, deployments → spawn_worker or delegate_to_worker
+- Quick checks or reads → bash
+- Long-running background tasks → spawn_worker (non-blocking)
+
+FILESYSTEM AWARENESS:
+You know the user's filesystem. Their projects, directories, and files are indexed in your memory.
+When they mention "that project", "the connect app", "downloads folder", etc. - SEARCH YOUR MEMORY.
+Use search_memory to find the actual paths before working.
+
+WHO YOU ARE:
+Warm, helpful, and genuinely interested in what the user is working on. Like a knowledgeable friend with superpowers - you remember their preferences, track their projects, and make things happen.
+
+WHAT YOU CAN DO:
+- Run shell commands directly with bash
+- Search the web and fetch URLs
+- Dispatch Claude Code workers for complex work
+- Start local servers and open browsers
+- Remember things across conversations
+- Schedule tasks for later
+- Have real conversations
+
+HOW TO TALK:
+- Be yourself - warm, direct, helpful
+- Keep it conversational
+- Show you remember them
+- Celebrate progress - "Nice, that's done!" not "Task completed successfully."
+- Be honest about what you're doing
+- If something fails, try a different approach or explain what happened
+
+SLASH COMMANDS:
+- /reset - Clear conversation and memory context
+- /verbose - Toggle showing tool execution details
+- /help - Show available commands
+
+You're the persistent layer that makes AI feel personal. You ACT on behalf of the user - you don't give them homework.`;
+export class MasterOrchestrator {
+    client;
+    model;
+    maxTokens;
+    memory;
+    scheduler;
+    indexer;
+    jobs = new Map();
+    jobCounter = 0;
+    userId;
+    workspaceDir;
+    claudePath;
+    initialized = false;
+    // New tools from whatsapp-claude
+    bashTool;
+    webTools;
+    workerTools;
+    verboseMode = new Map(); // per-user verbose mode
+    constructor(options) {
+        this.client = new Anthropic({ apiKey: options.apiKey });
+        this.model = options.model || 'claude-sonnet-4-20250514';
+        this.maxTokens = options.maxTokens || 4096;
+        this.userId = options.userId;
+        this.workspaceDir = options.workspaceDir || process.env.HOME || '/tmp';
+        // Find claude binary - critical for worker delegation
+        this.claudePath = this.findClaudeBinary();
+        console.log(`[ORCHESTRATOR] Claude binary: ${this.claudePath}`);
+        // Initialize memory with user-specific paths
+        this.memory = new AdvancedMemoryStore({
+            dbPath: `memories_${options.userId}.db`,
+            vectorPath: `./memory_vectors_${options.userId}`,
+            voyageApiKey: options.voyageApiKey
+        });
+        this.scheduler = new TaskScheduler(`scheduled_${options.userId}.json`);
+        // Create indexer (will index on first initialize call)
+        this.indexer = new SystemIndexer(this.memory);
+        // Initialize new tools
+        this.bashTool = new BashTool(this.workspaceDir);
+        this.webTools = new WebTools();
+        this.workerTools = new WorkerTools(this.workspaceDir);
+    }
+    /**
+     * Initialize the orchestrator - indexes filesystem on first call
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        console.log('[ORCHESTRATOR] Initializing...');
+        // Index the filesystem into memory
+        try {
+            const result = await this.indexer.indexHome();
+            console.log(`[ORCHESTRATOR] Filesystem indexed: ${result.projects} projects, ${result.directories} directories`);
+        }
+        catch (error) {
+            console.error('[ORCHESTRATOR] Filesystem indexing failed:', error);
+            // Continue anyway - indexing is a nice-to-have
+        }
+        this.initialized = true;
+    }
+    /**
+     * Find the claude binary path
+     */
+    findClaudeBinary() {
+        // Since we spawn with shell: true, just use 'claude' command
+        // Shell will resolve PATH correctly (including NVM)
+        // Verify it exists by running 'which claude'
+        try {
+            const path = execSync('which claude', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (path) {
+                console.log(`[ORCHESTRATOR] Claude found at: ${path}`);
+                return 'claude'; // Use command name, not path (shell resolves it)
+            }
+        }
+        catch {
+            console.warn('[ORCHESTRATOR] Warning: claude not found in PATH');
+        }
+        return 'claude';
+    }
+    /**
+     * Handle slash commands
+     */
+    handleSlashCommand(message) {
+        const lower = message.trim().toLowerCase();
+        if (lower === '/help') {
+            return `**Available Commands:**
+- \`/reset\` - Clear conversation context
+- \`/verbose\` - Toggle verbose mode (show tool execution details)
+- \`/help\` - Show this help message
+
+**What I can do:**
+- Run shell commands, search the web, fetch URLs
+- Spawn Claude Code workers for complex tasks
+- Remember things across our conversations
+- Schedule tasks for later
+- Start local servers and open your browser`;
+        }
+        if (lower === '/verbose') {
+            const current = this.verboseMode.get(this.userId) || false;
+            this.verboseMode.set(this.userId, !current);
+            return `Verbose mode ${!current ? 'enabled' : 'disabled'}. ${!current ? 'I\'ll show you what tools I\'m using.' : 'Back to concise mode.'}`;
+        }
+        if (lower === '/reset') {
+            // Note: actual conversation reset happens in the agent.ts caller
+            return 'Conversation reset. Fresh start!';
+        }
+        return null;
+    }
+    /**
+     * Check if verbose mode is enabled
+     */
+    isVerbose() {
+        return this.verboseMode.get(this.userId) || false;
+    }
+    /**
+     * Process a user message
+     * @param apiKey Optional per-request API key (overrides default)
+     */
+    async processMessage(message, conversationHistory = [], sendMessage, apiKey) {
+        // Handle slash commands first
+        const slashResponse = this.handleSlashCommand(message);
+        if (slashResponse) {
+            return slashResponse;
+        }
+        // Build context from memory
+        const memoryContext = await this.getMemoryContext(message);
+        // Build system prompt with genesis knowledge and memory context
+        const genesisKnowledge = getKnowledgeForPrompt();
+        let systemWithContext = SYSTEM_PROMPT + genesisKnowledge;
+        if (memoryContext) {
+            systemWithContext += `\n\nRELEVANT MEMORIES:\n${memoryContext}`;
+        }
+        // Add user message
+        const messages = [
+            ...conversationHistory,
+            { role: 'user', content: message }
+        ];
+        try {
+            const response = await this.runAgentLoop(messages, systemWithContext, sendMessage, apiKey);
+            // Auto-remember important things from the conversation
+            await this.autoRemember(message, response);
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return `Error: ${errorMessage}`;
+        }
+    }
+    /**
+     * Get relevant memory context for a message
+     */
+    async getMemoryContext(message) {
+        try {
+            const memories = await this.memory.search(message, { limit: 5 });
+            if (memories.length === 0)
+                return null;
+            return memories.map(m => `[${m.type}] ${m.content}`).join('\n');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Auto-remember important information from conversations
+     */
+    async autoRemember(userMessage, response) {
+        // Look for preference indicators
+        const prefIndicators = ['i prefer', 'i like', 'i always', 'i never', 'i use', 'my favorite'];
+        const lower = userMessage.toLowerCase();
+        for (const indicator of prefIndicators) {
+            if (lower.includes(indicator)) {
+                await this.memory.remember(userMessage, {
+                    type: 'semantic',
+                    source: 'auto-extract',
+                    importance: 0.7,
+                    tags: ['preference', 'user']
+                });
+                break;
+            }
+        }
+    }
+    /**
+     * Run the agentic loop
+     * @param apiKey Optional per-request API key (creates temporary client)
+     */
+    async runAgentLoop(messages, system, sendMessage, apiKey) {
+        const tools = this.getToolDefinitions();
+        let currentMessages = [...messages];
+        let iterations = 0;
+        const maxIterations = 30; // Increased for complex multi-tool tasks
+        // Use per-request client if apiKey provided, otherwise use default
+        const client = apiKey ? new Anthropic({ apiKey }) : this.client;
+        while (iterations < maxIterations) {
+            iterations++;
+            const response = await client.messages.create({
+                model: this.model,
+                max_tokens: this.maxTokens,
+                system,
+                tools,
+                messages: currentMessages
+            });
+            // Check if done
+            if (response.stop_reason === 'end_turn' || !this.hasToolUse(response.content)) {
+                return this.extractText(response.content);
+            }
+            // Process tool calls
+            const toolResults = await this.processToolCalls(response.content, sendMessage);
+            // Continue conversation
+            currentMessages = [
+                ...currentMessages,
+                { role: 'assistant', content: response.content },
+                { role: 'user', content: toolResults }
+            ];
+        }
+        return 'Maximum iterations reached.';
+    }
+    /**
+     * Get tool definitions for the orchestrator
+     */
+    getToolDefinitions() {
+        return [
+            // Direct bash execution - for simple commands
+            {
+                name: 'bash',
+                description: 'Execute a shell command directly. Use for simple commands like ls, cat, git status, npm install, etc. For complex multi-step tasks, use spawn_worker instead.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        command: {
+                            type: 'string',
+                            description: 'The bash command to execute'
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds (default: 30000, max: 120000)'
+                        }
+                    },
+                    required: ['command']
+                }
+            },
+            // Web tools
+            {
+                name: 'web_search',
+                description: 'Search the web for information. Returns titles, URLs, and snippets from search results.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'The search query'
+                        },
+                        num_results: {
+                            type: 'number',
+                            description: 'Number of results to return (default: 5, max: 10)'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'fetch_url',
+                description: 'Fetch and parse content from a URL. Returns extracted text content by default.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'The URL to fetch'
+                        },
+                        format: {
+                            type: 'string',
+                            enum: ['text', 'html', 'json'],
+                            description: 'Output format (default: text)'
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds (default: 10000)'
+                        }
+                    },
+                    required: ['url']
+                }
+            },
+            // Worker tools - for parallel/background tasks
+            {
+                name: 'spawn_worker',
+                description: 'Spawn a Claude Code worker for a complex task. Non-blocking - returns immediately with a job ID. Use check_worker to monitor progress.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string',
+                            description: 'The task description for the worker'
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds (default: 300000 / 5 min)'
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['low', 'normal', 'high', 'critical'],
+                            description: 'Task priority'
+                        }
+                    },
+                    required: ['task']
+                }
+            },
+            {
+                name: 'check_worker',
+                description: 'Check the status and result of a spawned worker.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        job_id: {
+                            type: 'string',
+                            description: 'The job ID from spawn_worker'
+                        }
+                    },
+                    required: ['job_id']
+                }
+            },
+            {
+                name: 'wait_worker',
+                description: 'Wait for a worker to complete and return its result. Blocks until done.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        job_id: {
+                            type: 'string',
+                            description: 'The job ID to wait for'
+                        },
+                        max_wait: {
+                            type: 'number',
+                            description: 'Maximum wait time in milliseconds'
+                        }
+                    },
+                    required: ['job_id']
+                }
+            },
+            {
+                name: 'list_workers',
+                description: 'List all worker jobs with their status.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        status: {
+                            type: 'string',
+                            description: 'Filter by status (running, completed, failed)'
+                        }
+                    },
+                    required: []
+                }
+            },
+            {
+                name: 'cancel_worker',
+                description: 'Cancel a running worker job.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        job_id: {
+                            type: 'string',
+                            description: 'The job ID to cancel'
+                        }
+                    },
+                    required: ['job_id']
+                }
+            },
+            // Delegate tool - for full CLI autonomy
+            {
+                name: 'delegate_to_worker',
+                description: `Delegate a task to Claude Code CLI worker. Use for complex multi-step tasks that need full CLI autonomy.
+
+Use this for ANY task that involves:
+- Reading, writing, or editing files
+- Running shell commands
+- Exploring codebases
+- Making code changes
+- Building, testing, deploying
+- ANY filesystem or system operation
+
+The worker will execute the task autonomously and return results.
+Be specific about what you want done.`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string',
+                            description: 'Detailed description of what the worker should do'
+                        },
+                        context: {
+                            type: 'string',
+                            description: 'Additional context (user preferences, project info, etc)'
+                        },
+                        working_directory: {
+                            type: 'string',
+                            description: 'Directory to work in (defaults to user home)'
+                        }
+                    },
+                    required: ['task']
+                }
+            },
+            {
+                name: 'remember',
+                description: 'Store something in persistent memory. Use for user preferences, project info, important facts.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        content: {
+                            type: 'string',
+                            description: 'What to remember'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['episodic', 'semantic', 'procedural'],
+                            description: 'Memory type: episodic (events), semantic (facts), procedural (how-to)'
+                        },
+                        importance: {
+                            type: 'number',
+                            description: 'Importance 0-1 (higher = remembered longer)'
+                        }
+                    },
+                    required: ['content']
+                }
+            },
+            {
+                name: 'search_memory',
+                description: 'Search your memory for relevant information. Use before delegating to include user context.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'What to search for'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['episodic', 'semantic', 'procedural'],
+                            description: 'Filter by memory type'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'schedule_task',
+                description: 'Schedule a task for future execution.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string',
+                            description: 'The task to execute later'
+                        },
+                        when: {
+                            type: 'string',
+                            description: 'When to run (e.g., "in 30 minutes", "daily at 9:00", "tomorrow at 14:00")'
+                        }
+                    },
+                    required: ['task', 'when']
+                }
+            },
+            {
+                name: 'list_scheduled',
+                description: 'List all scheduled tasks.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            },
+            {
+                name: 'memory_stats',
+                description: 'Get statistics about your memory system.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            },
+            {
+                name: 'open_browser',
+                description: 'Open a URL or file in the user\'s default browser. Use for opening localhost servers, web pages, or local HTML files.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'URL to open (e.g., http://localhost:8080, https://example.com, or file path)'
+                        }
+                    },
+                    required: ['url']
+                }
+            },
+            {
+                name: 'start_local_server',
+                description: 'Start a persistent HTTP server to serve a web project. Server runs in background and survives after this call. Use before open_browser for local web projects.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        directory: {
+                            type: 'string',
+                            description: 'Directory to serve (absolute path)'
+                        },
+                        port: {
+                            type: 'number',
+                            description: 'Port to serve on (default: 8080)'
+                        }
+                    },
+                    required: ['directory']
+                }
+            },
+            {
+                name: 'stop_local_server',
+                description: 'Stop a running local server on a specific port.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        port: {
+                            type: 'number',
+                            description: 'Port of the server to stop'
+                        }
+                    },
+                    required: ['port']
+                }
+            }
+        ];
+    }
+    /**
+     * Process tool calls
+     */
+    async processToolCalls(content, sendMessage) {
+        const toolUseBlocks = content.filter((block) => block.type === 'tool_use');
+        const results = [];
+        for (const toolUse of toolUseBlocks) {
+            const input = toolUse.input;
+            let result;
+            // Notify user of action
+            if (sendMessage) {
+                const preview = this.formatToolPreview(toolUse.name, input);
+                if (preview)
+                    await sendMessage(preview);
+            }
+            switch (toolUse.name) {
+                // New direct tools
+                case 'bash':
+                    result = await this.bashTool.execute(input.command, input.timeout);
+                    break;
+                case 'web_search':
+                    result = await this.webTools.webSearch(input.query, { numResults: input.num_results });
+                    break;
+                case 'fetch_url':
+                    result = await this.webTools.fetchUrl(input.url, {
+                        format: input.format,
+                        timeout: input.timeout
+                    });
+                    break;
+                // Worker tools
+                case 'spawn_worker':
+                    result = await this.workerTools.spawnWorker(input.task, {
+                        timeout: input.timeout,
+                        priority: input.priority
+                    });
+                    break;
+                case 'check_worker':
+                    result = await this.workerTools.checkWorker(input.job_id);
+                    break;
+                case 'wait_worker':
+                    result = await this.workerTools.waitWorker(input.job_id, input.max_wait);
+                    break;
+                case 'list_workers':
+                    result = await this.workerTools.listWorkers(input.status);
+                    break;
+                case 'cancel_worker':
+                    result = await this.workerTools.cancelWorker(input.job_id);
+                    break;
+                // Legacy delegate tool
+                case 'delegate_to_worker':
+                    result = await this.delegateToWorker(input.task, input.context, input.working_directory);
+                    break;
+                case 'remember':
+                    result = await this.executeRemember(input.content, input.type, input.importance);
+                    break;
+                case 'search_memory':
+                    result = await this.executeSearchMemory(input.query, input.type);
+                    break;
+                case 'schedule_task':
+                    result = await this.executeScheduleTask(input.task, input.when);
+                    break;
+                case 'list_scheduled':
+                    result = await this.executeListScheduled();
+                    break;
+                case 'memory_stats':
+                    result = await this.executeMemoryStats();
+                    break;
+                case 'open_browser':
+                    result = await this.executeOpenBrowser(input.url);
+                    break;
+                case 'start_local_server':
+                    result = await this.executeStartServer(input.directory, input.port);
+                    break;
+                case 'stop_local_server':
+                    result = await this.executeStopServer(input.port);
+                    break;
+                default:
+                    result = { success: false, output: `Unknown tool: ${toolUse.name}` };
+            }
+            // Anthropic API requires content to be non-empty when is_error is true
+            const content = result.output || result.error || 'Unknown error';
+            results.push({
+                type: 'tool_result',
+                tool_use_id: toolUse.id,
+                content,
+                is_error: !result.success
+            });
+        }
+        return results;
+    }
+    /**
+     * Delegate task to Claude Code CLI worker with retry logic
+     */
+    async delegateToWorker(task, context, workingDir, retryCount = 0) {
+        const maxRetries = 2;
+        const id = `worker_${Date.now()}_${++this.jobCounter}`;
+        const cwd = workingDir || this.workspaceDir;
+        // Build prompt for worker
+        let prompt = task;
+        if (context) {
+            prompt = `Context: ${context}\n\nTask: ${task}`;
+        }
+        prompt += '\n\nKeep your response concise and focused on results.';
+        console.log(`[ORCHESTRATOR] Delegating to worker ${id}: ${task.slice(0, 80)}...`);
+        return new Promise((resolve) => {
+            const job = {
+                id,
+                task: task.slice(0, 200),
+                status: 'running',
+                startTime: Date.now(),
+                output: ''
+            };
+            // Escape single quotes in prompt for shell safety
+            // Replace ' with '\'' (end quote, escaped quote, start quote)
+            const escapedPrompt = prompt.replace(/'/g, "'\\''");
+            // Spawn using bash -l -c to ensure proper PATH resolution (NVM, etc.)
+            // This is more reliable than shell: true which has quote escaping issues
+            const child = spawn('bash', ['-l', '-c', `claude -p '${escapedPrompt}' --dangerously-skip-permissions`], {
+                cwd,
+                env: { ...process.env },
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            job.process = child;
+            this.jobs.set(id, job);
+            // Timeout after 5 minutes
+            const timeout = setTimeout(() => {
+                if (job.status === 'running') {
+                    job.status = 'timeout';
+                    job.endTime = Date.now();
+                    child.kill('SIGTERM');
+                    resolve({
+                        success: false,
+                        output: `Worker timed out after 5 minutes.\nPartial output:\n${job.output.slice(-1000)}`
+                    });
+                }
+            }, 5 * 60 * 1000);
+            child.stdout?.on('data', (data) => {
+                job.output += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                // Ignore status messages
+                const text = data.toString();
+                if (!text.includes('Checking') && !text.includes('Connected')) {
+                    job.output += text;
+                }
+            });
+            child.on('close', (code) => {
+                clearTimeout(timeout);
+                job.status = code === 0 ? 'completed' : 'failed';
+                job.endTime = Date.now();
+                const duration = ((job.endTime - job.startTime) / 1000).toFixed(1);
+                console.log(`[ORCHESTRATOR] Worker ${id} finished in ${duration}s (code: ${code})`);
+                if (code !== 0 || job.output.length === 0) {
+                    console.log(`[ORCHESTRATOR] Worker ${id} output: ${job.output.slice(0, 200) || '(empty)'}`);
+                }
+                resolve({
+                    success: code === 0,
+                    output: job.output.trim() || '(No output)'
+                });
+            });
+            child.on('error', async (err) => {
+                clearTimeout(timeout);
+                job.status = 'failed';
+                job.endTime = Date.now();
+                console.error(`[ORCHESTRATOR] Worker ${id} spawn error:`, err.message);
+                // Retry on ENOENT (intermittent spawn failures)
+                if (err.message.includes('ENOENT') && retryCount < maxRetries) {
+                    console.log(`[ORCHESTRATOR] Retrying worker (attempt ${retryCount + 2}/${maxRetries + 1})...`);
+                    await new Promise(r => setTimeout(r, 500)); // Small delay before retry
+                    const retryResult = await this.delegateToWorker(task, context, workingDir, retryCount + 1);
+                    resolve(retryResult);
+                    return;
+                }
+                resolve({
+                    success: false,
+                    output: `Worker error: ${err.message}`
+                });
+            });
+        });
+    }
+    /**
+     * Execute remember tool
+     */
+    async executeRemember(content, type, importance) {
+        try {
+            const id = await this.memory.remember(content, {
+                type: type || undefined,
+                importance
+            });
+            return { success: true, output: `Remembered (${id})` };
+        }
+        catch (error) {
+            return { success: false, output: `Failed to remember: ${error}` };
+        }
+    }
+    /**
+     * Execute search memory tool
+     */
+    async executeSearchMemory(query, type) {
+        try {
+            const memories = await this.memory.search(query, {
+                type: type || undefined,
+                limit: 10
+            });
+            if (memories.length === 0) {
+                return { success: true, output: 'No relevant memories found.' };
+            }
+            const output = memories.map(m => `[${m.type}] (${(m.importance * 100).toFixed(0)}%) ${m.content}`).join('\n\n');
+            return { success: true, output };
+        }
+        catch (error) {
+            return { success: false, output: `Memory search failed: ${error}` };
+        }
+    }
+    /**
+     * Execute schedule task tool
+     */
+    async executeScheduleTask(task, when) {
+        try {
+            const taskId = this.scheduler.schedule(task, when, this.userId);
+            const scheduled = this.scheduler.get(taskId);
+            return {
+                success: true,
+                output: `Scheduled: ${taskId}\nWhen: ${scheduled ? this.scheduler.formatSchedule(scheduled.schedule) : when}`
+            };
+        }
+        catch (error) {
+            return { success: false, output: `Scheduling failed: ${error}` };
+        }
+    }
+    /**
+     * Execute list scheduled tool
+     */
+    async executeListScheduled() {
+        const tasks = this.scheduler.list();
+        if (tasks.length === 0) {
+            return { success: true, output: 'No scheduled tasks.' };
+        }
+        const output = tasks.map(t => `${t.enabled ? '✓' : '⏸'} ${t.id}: ${t.task.slice(0, 50)}... (${this.scheduler.formatSchedule(t.schedule)})`).join('\n');
+        return { success: true, output };
+    }
+    /**
+     * Execute memory stats tool
+     */
+    async executeMemoryStats() {
+        const stats = this.memory.stats();
+        return {
+            success: true,
+            output: `Memories: ${stats.total} (episodic: ${stats.byType.episodic}, semantic: ${stats.byType.semantic}, procedural: ${stats.byType.procedural})\nAvg importance: ${(stats.avgImportance * 100).toFixed(0)}%\nAssociations: ${stats.totalAssociations}`
+        };
+    }
+    /**
+     * Open a URL in the user's default browser
+     */
+    async executeOpenBrowser(url) {
+        try {
+            // Use 'open' on macOS, 'xdg-open' on Linux, 'start' on Windows
+            const platform = process.platform;
+            let command;
+            if (platform === 'darwin') {
+                command = 'open';
+            }
+            else if (platform === 'win32') {
+                command = 'start';
+            }
+            else {
+                command = 'xdg-open';
+            }
+            execSync(`${command} "${url}"`, { stdio: 'ignore' });
+            console.log(`[ORCHESTRATOR] Opened browser: ${url}`);
+            return { success: true, output: `Opened ${url} in browser` };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to open browser: ${msg}` };
+        }
+    }
+    /**
+     * Start a persistent HTTP server
+     */
+    async executeStartServer(directory, port = 8080) {
+        try {
+            // First, check if something is already running on this port
+            try {
+                const existing = execSync(`lsof -i :${port} -t`, { encoding: 'utf8' }).trim();
+                if (existing) {
+                    return {
+                        success: true,
+                        output: `Server already running on port ${port}. URL: http://localhost:${port}`
+                    };
+                }
+            }
+            catch {
+                // No process on port, good to start
+            }
+            // Verify directory exists
+            if (!existsSync(directory)) {
+                return { success: false, output: `Directory not found: ${directory}` };
+            }
+            // Start server with nohup so it persists
+            const cmd = `cd "${directory}" && nohup python3 -m http.server ${port} > /dev/null 2>&1 &`;
+            execSync(cmd, { shell: '/bin/bash' });
+            // Wait a moment for server to start
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Verify it started
+            try {
+                execSync(`lsof -i :${port} -t`, { encoding: 'utf8' });
+                console.log(`[ORCHESTRATOR] Started server on port ${port} for ${directory}`);
+                return {
+                    success: true,
+                    output: `Started HTTP server on http://localhost:${port} serving ${directory}`
+                };
+            }
+            catch {
+                return { success: false, output: `Server failed to start on port ${port}` };
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { success: false, output: `Failed to start server: ${msg}` };
+        }
+    }
+    /**
+     * Stop a running server on a port
+     */
+    async executeStopServer(port) {
+        try {
+            const pid = execSync(`lsof -i :${port} -t`, { encoding: 'utf8' }).trim();
+            if (pid) {
+                execSync(`kill ${pid}`);
+                console.log(`[ORCHESTRATOR] Stopped server on port ${port} (PID: ${pid})`);
+                return { success: true, output: `Stopped server on port ${port}` };
+            }
+            return { success: false, output: `No server running on port ${port}` };
+        }
+        catch {
+            return { success: false, output: `No server running on port ${port}` };
+        }
+    }
+    /**
+     * Format tool preview for user
+     */
+    formatToolPreview(name, input) {
+        // Only show previews in verbose mode
+        if (!this.isVerbose()) {
+            // Always show these regardless of verbose mode
+            if (name === 'delegate_to_worker' || name === 'spawn_worker') {
+                return `Working on: ${(input.task || '').slice(0, 60)}...`;
+            }
+            return null;
+        }
+        switch (name) {
+            case 'bash':
+                return `Running: ${input.command.slice(0, 60)}`;
+            case 'web_search':
+                return `Searching web: ${input.query}`;
+            case 'fetch_url':
+                return `Fetching: ${input.url}`;
+            case 'spawn_worker':
+                return `Spawning worker: ${input.task.slice(0, 60)}...`;
+            case 'check_worker':
+                return `Checking worker: ${input.job_id}`;
+            case 'wait_worker':
+                return `Waiting for worker: ${input.job_id}`;
+            case 'list_workers':
+                return 'Listing workers...';
+            case 'cancel_worker':
+                return `Canceling worker: ${input.job_id}`;
+            case 'delegate_to_worker':
+                return `Delegating: ${input.task.slice(0, 60)}...`;
+            case 'remember':
+                return `Remembering: ${input.content.slice(0, 50)}...`;
+            case 'search_memory':
+                return `Searching memory: ${input.query}`;
+            case 'schedule_task':
+                return `Scheduling: ${input.task} for ${input.when}`;
+            case 'open_browser':
+                return `Opening browser: ${input.url}`;
+            case 'start_local_server':
+                return `Starting server on port ${input.port || 8080}...`;
+            case 'stop_local_server':
+                return `Stopping server on port ${input.port}...`;
+            default:
+                return null;
+        }
+    }
+    hasToolUse(content) {
+        return content.some(block => block.type === 'tool_use');
+    }
+    extractText(content) {
+        const text = content
+            .filter(block => block.type === 'text')
+            .map(block => block.text)
+            .join('\n')
+            .trim();
+        // Never return empty - provide fallback
+        return text || 'Task completed.';
+    }
+    /**
+     * Shutdown cleanly
+     */
+    shutdown() {
+        this.scheduler.shutdown();
+        this.memory.close();
+    }
+}