@siftd/connect-agent 0.2.0 → 0.2.3

package/dist/orchestrator.js

@@ -5,85 +5,96 @@
  * It does NOT do the work itself. Claude Code CLI workers do the work.
  */
 import Anthropic from '@anthropic-ai/sdk';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
+import { existsSync } from 'fs';
 import { AdvancedMemoryStore } from './core/memory-advanced.js';
 import { TaskScheduler } from './core/scheduler.js';
-const SYSTEM_PROMPT = `You are the MASTER ORCHESTRATOR - the user's intelligent assistant accessed via web browser.
+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 IDENTITY:
-You are NOT a coding assistant. You are NOT a worker. You are the ORCHESTRATOR.
-Your job is to UNDERSTAND, REMEMBER, DELEGATE, and SYNTHESIZE.
+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.
 
-You have a powerful worker at your disposal: Claude Code CLI. It can:
-- Read, write, edit any file on the user's machine
-- Run any shell command
-- Explore codebases
-- Make multi-file changes
-- Run builds, tests, deployments
-- Do complex development work
+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
 
-YOUR ROLE vs WORKER ROLE:
-┌─────────────────────────────────────────────────────────────────┐
-│ YOU (Master Orchestrator)          │ WORKER (Claude Code CLI)  │
-├────────────────────────────────────┼────────────────────────────┤
-│ Understand user intent             │ Execute file operations   │
-│ Remember user preferences          │ Run shell commands        │
-│ Track ongoing projects             │ Make code changes         │
-│ Decide what needs to be done       │ Explore codebases         │
-│ Delegate complex tasks             │ Build/test/deploy         │
-│ Synthesize results for user        │ Handle multi-step tasks   │
-│ Schedule future work               │ Do the actual work        │
-│ Maintain conversation context      │ Work autonomously         │
-└────────────────────────────────────┴────────────────────────────┘
+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)
 
-DELEGATION STRATEGY:
-- ALWAYS delegate: file operations, code changes, builds, tests, deployments
-- ALWAYS delegate: multi-step tasks, codebase exploration
-- ALWAYS delegate: anything requiring filesystem or shell access
-- Handle yourself: simple questions, scheduling, memory operations, conversation
+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.
 
-NEVER TRY TO DO THE WORK YOURSELF. You don't have filesystem access. You don't have shell access.
-Your only tools are: delegate_to_worker, remember, search_memory, schedule_task.
+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.
 
-WHEN YOU DELEGATE:
-1. Be specific about what you want done
-2. Include context about user preferences from memory
-3. Tell the user you're delegating ("Let me have my worker handle that...")
-4. Wait for results and synthesize them into a clear response
+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
 
-MEMORY SYSTEM:
-You have persistent memory. Use it to:
-- Remember user preferences ("I prefer TypeScript", "I use pnpm")
-- Track ongoing projects and their status
-- Note user's communication style
-- Store important facts about the user's system/environment
-- Remember past conversations and decisions
+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
 
-COMMUNICATION STYLE:
-- Be concise - this is a chat interface, not documentation
-- Be direct - say what you're doing
-- Be helpful - anticipate needs based on memory
-- Acknowledge the user as someone you know and work with
+SLASH COMMANDS:
+- /reset - Clear conversation and memory context
+- /verbose - Toggle showing tool execution details
+- /help - Show available commands
 
-You are the user's intelligent agent - you remember them, understand their projects,
-and orchestrate work on their behalf. You are the persistent layer that makes
-working with AI feel like having a knowledgeable assistant who knows you.`;
+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`,
@@ -91,24 +102,110 @@ export class MasterOrchestrator {
             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) {
+    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 memory context
-        const systemWithMemory = memoryContext
-            ? `${SYSTEM_PROMPT}\n\nRELEVANT MEMORIES:\n${memoryContext}`
-            : SYSTEM_PROMPT;
+        // 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, systemWithMemory, sendMessage);
+            const response = await this.runAgentLoop(messages, systemWithContext, sendMessage, apiKey);
             // Auto-remember important things from the conversation
             await this.autoRemember(message, response);
             return response;
@@ -153,15 +250,18 @@ export class MasterOrchestrator {
     }
     /**
      * Run the agentic loop
+     * @param apiKey Optional per-request API key (creates temporary client)
      */
-    async runAgentLoop(messages, system, sendMessage) {
+    async runAgentLoop(messages, system, sendMessage, apiKey) {
         const tools = this.getToolDefinitions();
         let currentMessages = [...messages];
         let iterations = 0;
-        const maxIterations = 15;
+        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 this.client.messages.create({
+            const response = await client.messages.create({
                 model: this.model,
                 max_tokens: this.maxTokens,
                 system,
@@ -188,9 +288,155 @@ export class MasterOrchestrator {
      */
     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. This is your PRIMARY tool.
+                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
@@ -298,6 +544,52 @@ Be specific about what you want done.`,
                     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']
+                }
             }
         ];
     }
@@ -317,6 +609,39 @@ Be specific about what you want done.`,
                     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;
@@ -335,22 +660,34 @@ Be specific about what you want done.`,
                 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: result.output,
+                content,
                 is_error: !result.success
             });
         }
         return results;
     }
     /**
-     * Delegate task to Claude Code CLI worker
+     * Delegate task to Claude Code CLI worker with retry logic
      */
-    async delegateToWorker(task, context, workingDir) {
+    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
@@ -368,19 +705,18 @@ Be specific about what you want done.`,
                 startTime: Date.now(),
                 output: ''
             };
-            // Spawn Claude Code CLI - use -p flag and pipe prompt to stdin
-            const child = spawn('claude', ['-p'], {
+            // 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 },
-                shell: false
+                stdio: ['pipe', 'pipe', 'pipe']
             });
             job.process = child;
             this.jobs.set(id, job);
-            // Send prompt to stdin
-            if (child.stdin) {
-                child.stdin.write(prompt);
-                child.stdin.end();
-            }
             // Timeout after 5 minutes
             const timeout = setTimeout(() => {
                 if (job.status === 'running') {
@@ -408,16 +744,28 @@ Be specific about what you want done.`,
                 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`);
+                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', (err) => {
+            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}`
@@ -496,19 +844,137 @@ Be specific about what you want done.`,
             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 to worker: ${input.task.slice(0, 80)}...`;
+                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;
         }
@@ -517,10 +983,13 @@ Be specific about what you want done.`,
         return content.some(block => block.type === 'tool_use');
     }
     extractText(content) {
-        return content
+        const text = content
             .filter(block => block.type === 'text')
             .map(block => block.text)
-            .join('\n');
+            .join('\n')
+            .trim();
+        // Never return empty - provide fallback
+        return text || 'Task completed.';
     }
     /**
      * Shutdown cleanly