@siftd/connect-agent 0.2.14 → 0.2.16

package/dist/agent.js

@@ -211,6 +211,19 @@ export async function runAgent(pollInterval = 2000) {
     // Try WebSocket first
     wsClient = new AgentWebSocket();
     const wsConnected = await wsClient.connect();
+    // Always set up worker status callback for progress bars (works with or without WebSocket)
+    if (orchestrator) {
+        orchestrator.setWorkerStatusCallback((workers) => {
+            if (wsClient?.connected()) {
+                wsClient.sendWorkersUpdate(workers);
+            }
+            // Log running workers count for visibility even without WebSocket
+            const running = workers.filter(w => w.status === 'running');
+            if (running.length > 0) {
+                console.log(`[WORKERS] ${running.length} running: ${running.map(w => `${w.id} (${w.progress}%)`).join(', ')}`);
+            }
+        });
+    }
     if (wsConnected) {
         console.log('[AGENT] Using WebSocket for real-time communication\n');
         // Handle messages via WebSocket

package/dist/heartbeat.js

@@ -10,7 +10,7 @@ import { hostname } from 'os';
 import { createHash } from 'crypto';
 import { getServerUrl, getAgentToken, getUserId, isCloudMode } from './config.js';
 const HEARTBEAT_INTERVAL = 10000; // 10 seconds
-const VERSION = '0.2.14'; // Should match package.json
+const VERSION = '0.2.16'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -6,6 +6,15 @@
  */
 import type { MessageParam } from '@anthropic-ai/sdk/resources/messages';
 export type MessageSender = (message: string) => Promise<void>;
+export interface WorkerStatus {
+    id: string;
+    task: string;
+    status: 'running' | 'completed' | 'failed' | 'timeout';
+    progress: number;
+    elapsed: number;
+    estimated: number;
+}
+export type WorkerStatusCallback = (workers: WorkerStatus[]) => void;
 export declare class MasterOrchestrator {
     private client;
     private model;
@@ -15,6 +24,8 @@ export declare class MasterOrchestrator {
     private indexer;
     private jobs;
     private jobCounter;
+    private workerStatusCallback;
+    private workerStatusInterval;
     private userId;
     private workspaceDir;
     private claudePath;
@@ -36,6 +47,22 @@ export declare class MasterOrchestrator {
      * Initialize the orchestrator - indexes filesystem on first call
      */
     initialize(): Promise<void>;
+    /**
+     * Set callback for worker status updates (for UI progress bars)
+     */
+    setWorkerStatusCallback(callback: WorkerStatusCallback | null): void;
+    /**
+     * Get current status of all workers (from both delegateToWorker and spawn_worker)
+     */
+    getWorkerStatus(): WorkerStatus[];
+    /**
+     * Broadcast worker status to callback
+     */
+    private broadcastWorkerStatus;
+    /**
+     * Estimate task duration based on content
+     */
+    private estimateTaskDuration;
     /**
      * Find the claude binary path
      */
@@ -76,6 +103,7 @@ export declare class MasterOrchestrator {
     private processToolCalls;
     /**
      * Delegate task to Claude Code CLI worker with retry logic
+     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
      */
     private delegateToWorker;
     /**

package/dist/orchestrator.js

@@ -16,60 +16,63 @@ import { WebTools } from './tools/web.js';
 import { WorkerTools } from './tools/worker.js';
 import { SharedState } from './workers/shared-state.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.
+const SYSTEM_PROMPT = `You are a MASTER ORCHESTRATOR - NOT a worker. You delegate ALL file/code work to Claude Code CLI workers.
 
-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.
+CRITICAL IDENTITY:
+- You are the BRAIN, not the hands
+- You ORCHESTRATE workers - you don't do the work yourself
+- You REMEMBER everything using your memory tools
+- You PLAN and COORDINATE, then delegate execution
 
-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
+STRICT TOOL USAGE RULES:
 
-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)
+✅ USE bash ONLY for READ-ONLY operations:
+- ls, pwd, cat, head, tail, find, which, echo, date
+- git status, git log, git diff (viewing only)
+- Checking if files/directories exist
 
-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 use bash for:
+- Creating files (echo >, touch, mkdir)
+- Editing files (sed, awk, tee)
+- Moving/copying/deleting (mv, cp, rm)
+- Installing packages (npm install, pip install)
+- Running builds or tests
+- ANY file modification whatsoever
 
-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.
+✅ USE delegate_to_worker or spawn_worker for:
+- Creating, editing, or deleting ANY files
+- Running npm/pip/cargo install
+- Building, testing, deploying
+- Complex multi-step tasks
+- ANY filesystem modification
 
-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 IS MANDATORY:
+- ALWAYS use search_memory before starting work
+- ALWAYS use remember after significant actions
+- Log your orchestration decisions to memory
+- Learn from failures - remember what went wrong
 
-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
+WORKER ORCHESTRATION:
+- spawn_worker: For parallel/background tasks (non-blocking)
+- delegate_to_worker: For sequential tasks needing full autonomy
+- ALWAYS include logging instructions in worker prompts
+- Tell workers to save their logs to /tmp/worker-{job_id}.log
+
+AFTER EVERY SIGNIFICANT ACTION:
+1. Log it to memory with remember
+2. Note what worked or failed
+3. Update your understanding of the user's system
+
+WHO YOU ARE:
+Warm, helpful orchestrator. You coordinate, remember, and delegate. You're the persistent layer that makes AI feel personal - but you do it by managing workers, not by doing tasks yourself.
 
 SLASH COMMANDS:
 - /reset - Clear conversation and memory context
-- /verbose - Toggle showing tool execution details
+- /mode - Show current mode and capabilities
+- /memory - Show memory stats
 - /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.`;
+You ACT through workers. You REMEMBER through memory. You NEVER do file operations directly.`;
 export class MasterOrchestrator {
     client;
     model;
@@ -79,6 +82,8 @@ export class MasterOrchestrator {
     indexer;
     jobs = new Map();
     jobCounter = 0;
+    workerStatusCallback = null;
+    workerStatusInterval = null;
     userId;
     workspaceDir;
     claudePath;
@@ -140,6 +145,128 @@ export class MasterOrchestrator {
         }
         this.initialized = true;
     }
+    /**
+     * Set callback for worker status updates (for UI progress bars)
+     */
+    setWorkerStatusCallback(callback) {
+        this.workerStatusCallback = callback;
+        if (callback) {
+            // Start broadcasting status every 500ms when workers are running
+            if (!this.workerStatusInterval) {
+                this.workerStatusInterval = setInterval(() => {
+                    this.broadcastWorkerStatus();
+                }, 500);
+            }
+        }
+        else {
+            // Stop broadcasting
+            if (this.workerStatusInterval) {
+                clearInterval(this.workerStatusInterval);
+                this.workerStatusInterval = null;
+            }
+        }
+    }
+    /**
+     * Get current status of all workers (from both delegateToWorker and spawn_worker)
+     */
+    getWorkerStatus() {
+        const now = Date.now();
+        const workers = [];
+        // Include jobs from delegateToWorker (this.jobs)
+        for (const [id, job] of this.jobs) {
+            const elapsed = (now - job.startTime) / 1000;
+            const estimated = job.estimatedTime;
+            // Calculate progress: cap at 90% while running, 100% when done
+            let progress;
+            if (job.status === 'completed') {
+                progress = 100;
+            }
+            else if (job.status === 'failed' || job.status === 'timeout') {
+                progress = 100; // Show as complete even on failure
+            }
+            else {
+                progress = Math.min(90, (elapsed / estimated) * 100);
+            }
+            workers.push({
+                id,
+                task: job.task.slice(0, 60),
+                status: job.status,
+                progress: Math.round(progress),
+                elapsed: Math.round(elapsed),
+                estimated: Math.round(estimated)
+            });
+        }
+        // Also include jobs from spawn_worker (workerTools)
+        try {
+            const spawnedWorkers = this.workerTools.getRunningWorkers();
+            for (const worker of spawnedWorkers) {
+                // Don't duplicate if already in this.jobs
+                if (workers.some(w => w.id === worker.id))
+                    continue;
+                const elapsed = (now - worker.startTime) / 1000;
+                const estimated = worker.estimatedTime;
+                const progress = Math.min(90, (elapsed / estimated) * 100);
+                workers.push({
+                    id: worker.id,
+                    task: worker.task.slice(0, 60),
+                    status: worker.status,
+                    progress: Math.round(progress),
+                    elapsed: Math.round(elapsed),
+                    estimated: Math.round(estimated)
+                });
+            }
+        }
+        catch (error) {
+            // WorkerTools not available, skip
+        }
+        return workers;
+    }
+    /**
+     * Broadcast worker status to callback
+     */
+    broadcastWorkerStatus() {
+        if (!this.workerStatusCallback)
+            return;
+        const workers = this.getWorkerStatus();
+        // Only broadcast if there are running workers
+        const hasRunning = workers.some(w => w.status === 'running');
+        if (hasRunning || workers.length > 0) {
+            this.workerStatusCallback(workers);
+        }
+        // Clean up completed jobs after 3 seconds
+        const now = Date.now();
+        for (const [id, job] of this.jobs) {
+            if (job.status !== 'running' && job.endTime && (now - job.endTime) > 3000) {
+                this.jobs.delete(id);
+            }
+        }
+    }
+    /**
+     * Estimate task duration based on content
+     */
+    estimateTaskDuration(task) {
+        const lower = task.toLowerCase();
+        // Complex tasks: 3 minutes
+        if (lower.includes('refactor') || lower.includes('implement') ||
+            lower.includes('create') || lower.includes('build') ||
+            lower.includes('write tests') || lower.includes('add tests')) {
+            return 180;
+        }
+        // Medium tasks: 90 seconds
+        if (lower.includes('fix') || lower.includes('update') ||
+            lower.includes('modify') || lower.includes('change') ||
+            lower.includes('add') || lower.includes('install')) {
+            return 90;
+        }
+        // Simple tasks: 45 seconds
+        if (lower.includes('find') || lower.includes('search') ||
+            lower.includes('read') || lower.includes('list') ||
+            lower.includes('check') || lower.includes('show')) {
+            return 45;
+        }
+        // Default: 60 seconds
+        return 60;
+    }
     /**
      * Find the claude binary path
      */
@@ -301,16 +428,21 @@ export class MasterOrchestrator {
      */
     getToolDefinitions() {
         return [
-            // Direct bash execution - for simple commands
+            // Direct bash execution - READ-ONLY OPERATIONS ONLY
             {
                 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.',
+                description: `Execute a READ-ONLY shell command. ONLY use for viewing/checking - NEVER for modifications.
+
+ALLOWED: ls, pwd, cat, head, tail, find, which, echo, date, git status, git log, git diff, test -f, test -d
+FORBIDDEN: touch, mkdir, rm, mv, cp, echo >, tee, sed -i, npm install, pip install, ANY file creation/modification
+
+For ANY file creation, editing, or system modification, use delegate_to_worker instead.`,
                 input_schema: {
                     type: 'object',
                     properties: {
                         command: {
                             type: 'string',
-                            description: 'The bash command to execute'
+                            description: 'READ-ONLY bash command (no file modifications allowed)'
                         },
                         timeout: {
                             type: 'number',
@@ -698,9 +830,12 @@ Be specific about what you want done.`,
     }
     /**
      * Delegate task to Claude Code CLI worker with retry logic
+     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
      */
-    async delegateToWorker(task, context, workingDir, retryCount = 0) {
+    async delegateToWorker(task, context, workingDir, retryCount = 0, timeoutMs) {
         const maxRetries = 2;
+        // Default 30 min, max 60 min
+        const workerTimeout = Math.min(timeoutMs || 30 * 60 * 1000, 60 * 60 * 1000);
         const id = `worker_${Date.now()}_${++this.jobCounter}`;
         const cwd = workingDir || this.workspaceDir;
         // Search for relevant memories to inject into worker prompt
@@ -757,13 +892,16 @@ If you need to share data with other workers or signal completion:
 [MESSAGE] to=worker_xyz | content=Please review the changes I made
 This enables parallel workers to coordinate.`;
         console.log(`[ORCHESTRATOR] Delegating to worker ${id}: ${task.slice(0, 80)}...`);
+        // Estimate task duration based on content
+        const estimatedTime = this.estimateTaskDuration(task);
         return new Promise((resolve) => {
             const job = {
                 id,
                 task: task.slice(0, 200),
                 status: 'running',
                 startTime: Date.now(),
-                output: ''
+                output: '',
+                estimatedTime
             };
             // Escape single quotes in prompt for shell safety
             // Replace ' with '\'' (end quote, escaped quote, start quote)
@@ -777,8 +915,8 @@ This enables parallel workers to coordinate.`;
             });
             job.process = child;
             this.jobs.set(id, job);
-            // Timeout after 10 minutes (increased from 5 for complex tasks)
-            const WORKER_TIMEOUT = 10 * 60 * 1000;
+            // Configurable timeout (default 30 min, max 60 min)
+            const timeoutMinutes = Math.round(workerTimeout / 60000);
             const timeout = setTimeout(() => {
                 if (job.status === 'running') {
                     job.status = 'timeout';
@@ -792,14 +930,16 @@ This enables parallel workers to coordinate.`;
                         }
                     }, 5000);
                     const partialOutput = job.output.trim();
+                    // Check for log file that worker should have created
+                    const logFile = `/tmp/worker-${id}-log.txt`;
                     resolve({
                         success: false,
                         output: partialOutput
-                            ? `Worker timed out after 10 minutes. Partial findings:\n${partialOutput.slice(-2000)}`
-                            : 'Worker timed out after 10 minutes with no output. The task may be too complex - try breaking it into smaller steps.'
+                            ? `Worker timed out after ${timeoutMinutes} minutes. Check ${logFile} for full logs. Partial findings:\n${partialOutput.slice(-3000)}`
+                            : `Worker timed out after ${timeoutMinutes} minutes with no output. Check ${logFile} for any saved progress.`
                     });
                 }
-            }, WORKER_TIMEOUT);
+            }, workerTimeout);
             child.stdout?.on('data', (data) => {
                 job.output += data.toString();
             });
@@ -1141,6 +1281,11 @@ This enables parallel workers to coordinate.`;
      * Shutdown cleanly
      */
     async shutdown() {
+        // Stop worker status broadcasting
+        if (this.workerStatusInterval) {
+            clearInterval(this.workerStatusInterval);
+            this.workerStatusInterval = null;
+        }
         this.scheduler.shutdown();
         if (this.memory instanceof PostgresMemoryStore) {
             await this.memory.close();

package/dist/tools/worker.d.ts

@@ -33,4 +33,18 @@ export declare class WorkerTools {
      * Clean up old jobs
      */
     cleanupWorkers(): Promise<ToolResult>;
+    /**
+     * Get all running workers for progress tracking
+     */
+    getRunningWorkers(): Array<{
+        id: string;
+        task: string;
+        status: string;
+        startTime: number;
+        estimatedTime: number;
+    }>;
+    /**
+     * Estimate task duration based on content
+     */
+    private estimateTaskDuration;
 }

package/dist/tools/worker.js

@@ -146,4 +146,37 @@ export class WorkerTools {
             output: `Cleaned up ${cleaned} old job(s).`
         };
     }
+    /**
+     * Get all running workers for progress tracking
+     */
+    getRunningWorkers() {
+        const jobs = this.manager.list({ status: 'running' });
+        return jobs.map(job => ({
+            id: job.id,
+            task: job.task,
+            status: job.status,
+            startTime: job.started ? new Date(job.started).getTime() : Date.now(),
+            // Estimate based on task content
+            estimatedTime: this.estimateTaskDuration(job.task)
+        }));
+    }
+    /**
+     * Estimate task duration based on content
+     */
+    estimateTaskDuration(task) {
+        const lower = task.toLowerCase();
+        if (lower.includes('refactor') || lower.includes('implement') ||
+            lower.includes('create') || lower.includes('build')) {
+            return 180; // 3 minutes
+        }
+        if (lower.includes('fix') || lower.includes('update') ||
+            lower.includes('modify') || lower.includes('add')) {
+            return 90; // 90 seconds
+        }
+        if (lower.includes('find') || lower.includes('search') ||
+            lower.includes('read') || lower.includes('list')) {
+            return 45; // 45 seconds
+        }
+        return 60; // default 1 minute
+    }
 }

package/dist/websocket.d.ts

@@ -6,6 +6,7 @@
  * - Streams responses as they're generated
  * - Supports interruption and progress updates
  */
+import type { WorkerStatus } from './orchestrator.js';
 export type MessageHandler = (message: WebSocketMessage) => Promise<void>;
 export type StreamHandler = (chunk: string) => void;
 export interface WebSocketMessage {
@@ -57,6 +58,10 @@ export declare class AgentWebSocket {
      * Send typing indicator
      */
     sendTyping(isTyping: boolean): void;
+    /**
+     * Send workers status update for progress bars
+     */
+    sendWorkersUpdate(workers: WorkerStatus[]): void;
     /**
      * Check if connected
      */

package/dist/websocket.js

@@ -159,6 +159,15 @@ export class AgentWebSocket {
             isTyping
         });
     }
+    /**
+     * Send workers status update for progress bars
+     */
+    sendWorkersUpdate(workers) {
+        this.sendToServer({
+            type: 'workers_update',
+            workers
+        });
+    }
     /**
      * Check if connected
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",