@siftd/connect-agent 0.2.19 → 0.2.21

package/dist/agent.js

@@ -181,9 +181,9 @@ export async function processMessage(message) {
         );
         return response;
     }
-    // Handle self-update requests - trigger on "update" keyword
-    if (content.includes('update') && (content.includes('agent') || content.includes('yourself') || content.includes('latest'))) {
-        console.log('[AGENT] Update request detected');
+    // System command: force update (sent by webapp banner)
+    if (content === '/system-update') {
+        console.log('[AGENT] === SYSTEM UPDATE COMMAND ===');
         return await performSelfUpdate();
     }
     try {
@@ -245,16 +245,24 @@ 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)
+    // Set up worker callbacks
     if (orchestrator) {
+        // Progress bars
         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(', ')}`);
+                console.log(`[WORKERS] ${running.length} running`);
+            }
+        });
+        // Worker results - send to user when workers complete
+        orchestrator.setWorkerResultCallback((workerId, result) => {
+            console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);
+            if (wsClient?.connected()) {
+                // Send as response with worker ID as message ID
+                wsClient.sendResponse(workerId, `**Worker completed:**\n\n${result}`);
             }
         });
     }

package/dist/core/hub.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Hub - The Agent's Brain Home
+ *
+ * Manages structured memory files in ~/.connect-hub/
+ * Human-readable markdown files that the orchestrator reads/writes.
+ */
+export interface HubContext {
+    agentIdentity: string;
+    landmarks: string;
+    projectBio: string | null;
+    projectName: string | null;
+}
+/**
+ * Ensure hub directory structure exists
+ */
+export declare function ensureHubExists(): void;
+/**
+ * Load hub context for a session
+ * Reads AGENTS.md, LANDMARKS.md, and relevant project bio
+ */
+export declare function loadHubContext(message?: string): HubContext;
+/**
+ * Format hub context for inclusion in system prompt
+ */
+export declare function formatHubContext(ctx: HubContext): string;
+/**
+ * Append to action log
+ */
+export declare function logAction(action: string, project?: string, details?: string): void;
+/**
+ * Update or create a project bio
+ */
+export declare function updateProjectBio(projectName: string, content: string): void;
+/**
+ * Append learning to a project bio
+ */
+export declare function appendToProjectBio(projectName: string, section: string, content: string): void;
+/**
+ * Log a mistake for learning
+ */
+export declare function logMistake(what: string, rootCause: string, fix: string, lesson: string): void;
+/**
+ * Update LANDMARKS.md with current state
+ */
+export declare function updateLandmarks(content: string): void;

package/dist/core/hub.js

@@ -0,0 +1,231 @@
+/**
+ * Hub - The Agent's Brain Home
+ *
+ * Manages structured memory files in ~/.connect-hub/
+ * Human-readable markdown files that the orchestrator reads/writes.
+ */
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const HUB_DIR = join(homedir(), '.connect-hub');
+const PROJECTS_DIR = join(HUB_DIR, 'projects');
+/**
+ * Ensure hub directory structure exists
+ */
+export function ensureHubExists() {
+    if (!existsSync(HUB_DIR)) {
+        mkdirSync(HUB_DIR, { recursive: true });
+    }
+    if (!existsSync(PROJECTS_DIR)) {
+        mkdirSync(PROJECTS_DIR, { recursive: true });
+    }
+}
+/**
+ * Read a hub file safely
+ */
+function readHubFile(filename) {
+    const path = join(HUB_DIR, filename);
+    if (existsSync(path)) {
+        try {
+            return readFileSync(path, 'utf-8');
+        }
+        catch (e) {
+            console.error(`[HUB] Failed to read ${filename}:`, e);
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Read a project bio
+ */
+function readProjectBio(projectName) {
+    // Normalize project name (lowercase, hyphens)
+    const normalized = projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const path = join(PROJECTS_DIR, `${normalized}.md`);
+    if (existsSync(path)) {
+        try {
+            return readFileSync(path, 'utf-8');
+        }
+        catch (e) {
+            console.error(`[HUB] Failed to read project bio ${normalized}:`, e);
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Detect project name from message content
+ */
+function detectProject(message) {
+    // Common project patterns
+    const patterns = [
+        /\b(connect[-_]?app[-_]?2?)\b/i,
+        /\b(lia[-_]?live)\b/i,
+        /\b(game[-_]?001)\b/i,
+        /\bproj(?:ect)?[-_:]?\s*([a-z0-9-]+)/i,
+        /\bin\s+([a-z0-9-]+)\s+(?:project|repo|codebase)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = message.match(pattern);
+        if (match) {
+            return match[1].toLowerCase().replace(/[^a-z0-9-]/g, '-');
+        }
+    }
+    return null;
+}
+/**
+ * Load hub context for a session
+ * Reads AGENTS.md, LANDMARKS.md, and relevant project bio
+ */
+export function loadHubContext(message) {
+    ensureHubExists();
+    const agentIdentity = readHubFile('AGENTS.md') || '';
+    const landmarks = readHubFile('LANDMARKS.md') || '';
+    let projectBio = null;
+    let projectName = null;
+    // Try to detect project from message
+    if (message) {
+        projectName = detectProject(message);
+        if (projectName) {
+            projectBio = readProjectBio(projectName);
+        }
+    }
+    return {
+        agentIdentity,
+        landmarks,
+        projectBio,
+        projectName
+    };
+}
+/**
+ * Format hub context for inclusion in system prompt
+ */
+export function formatHubContext(ctx) {
+    const parts = [];
+    if (ctx.landmarks) {
+        parts.push(`## Current State (LANDMARKS)\n\n${ctx.landmarks}`);
+    }
+    if (ctx.projectBio && ctx.projectName) {
+        parts.push(`## Project Context: ${ctx.projectName}\n\n${ctx.projectBio}`);
+    }
+    return parts.join('\n\n---\n\n');
+}
+/**
+ * Append to action log
+ */
+export function logAction(action, project, details) {
+    ensureHubExists();
+    const logPath = join(HUB_DIR, 'ACTION-LOG.md');
+    const now = new Date();
+    const timestamp = now.toISOString().slice(0, 16).replace('T', ' ');
+    const projectPart = project ? ` — ${project}` : '';
+    const detailsPart = details ? ` — ${details}` : '';
+    const entry = `${timestamp}${projectPart} — ${action}${detailsPart}\n`;
+    try {
+        appendFileSync(logPath, entry);
+    }
+    catch (e) {
+        console.error('[HUB] Failed to write action log:', e);
+    }
+}
+/**
+ * Update or create a project bio
+ */
+export function updateProjectBio(projectName, content) {
+    ensureHubExists();
+    const normalized = projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const path = join(PROJECTS_DIR, `${normalized}.md`);
+    try {
+        writeFileSync(path, content);
+        console.log(`[HUB] Updated project bio: ${normalized}`);
+    }
+    catch (e) {
+        console.error(`[HUB] Failed to write project bio ${normalized}:`, e);
+    }
+}
+/**
+ * Append learning to a project bio
+ */
+export function appendToProjectBio(projectName, section, content) {
+    ensureHubExists();
+    const normalized = projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const path = join(PROJECTS_DIR, `${normalized}.md`);
+    try {
+        let existing = '';
+        if (existsSync(path)) {
+            existing = readFileSync(path, 'utf-8');
+        }
+        else {
+            existing = `# Project: ${projectName}\n\n`;
+        }
+        // Append under the section
+        const sectionHeader = `## ${section}`;
+        if (existing.includes(sectionHeader)) {
+            // Append to existing section
+            const parts = existing.split(sectionHeader);
+            const afterSection = parts[1] || '';
+            const nextSectionIndex = afterSection.indexOf('\n## ');
+            if (nextSectionIndex > -1) {
+                // Insert before next section
+                const sectionContent = afterSection.slice(0, nextSectionIndex);
+                const rest = afterSection.slice(nextSectionIndex);
+                existing = parts[0] + sectionHeader + sectionContent + '\n' + content + '\n' + rest;
+            }
+            else {
+                // Append at end
+                existing = existing + '\n' + content + '\n';
+            }
+        }
+        else {
+            // Create new section
+            existing = existing + `\n${sectionHeader}\n\n${content}\n`;
+        }
+        writeFileSync(path, existing);
+    }
+    catch (e) {
+        console.error(`[HUB] Failed to append to project bio ${normalized}:`, e);
+    }
+}
+/**
+ * Log a mistake for learning
+ */
+export function logMistake(what, rootCause, fix, lesson) {
+    ensureHubExists();
+    const path = join(HUB_DIR, 'MISTAKES.md');
+    const now = new Date();
+    const date = now.toISOString().slice(0, 10);
+    const entry = `
+---
+
+## ${date} — ${what}
+
+**What happened**: ${what}
+
+**Root cause**: ${rootCause}
+
+**Fix**: ${fix}
+
+**Lesson**: ${lesson}
+`;
+    try {
+        appendFileSync(path, entry);
+    }
+    catch (e) {
+        console.error('[HUB] Failed to write mistake log:', e);
+    }
+}
+/**
+ * Update LANDMARKS.md with current state
+ */
+export function updateLandmarks(content) {
+    ensureHubExists();
+    const path = join(HUB_DIR, 'LANDMARKS.md');
+    try {
+        writeFileSync(path, content);
+        console.log('[HUB] Updated LANDMARKS.md');
+    }
+    catch (e) {
+        console.error('[HUB] Failed to update LANDMARKS.md:', e);
+    }
+}

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.19'; // Should match package.json
+const VERSION = '0.2.20'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -101,9 +101,14 @@ export declare class MasterOrchestrator {
      * Process tool calls
      */
     private processToolCalls;
+    private workerResultCallback;
     /**
-     * Delegate task to Claude Code CLI worker with retry logic
-     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
+     * Set callback for when workers complete (for async notification)
+     */
+    setWorkerResultCallback(callback: ((workerId: string, result: string) => void) | null): void;
+    /**
+     * Delegate task to Claude Code CLI worker - NON-BLOCKING
+     * Returns immediately, sends results via callback when done
      */
     private delegateToWorker;
     /**

package/dist/orchestrator.js

@@ -16,6 +16,7 @@ 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';
+import { loadHubContext, formatHubContext, logAction } from './core/hub.js';
 const SYSTEM_PROMPT = `You are a MASTER ORCHESTRATOR - NOT a worker. You delegate ALL file/code work to Claude Code CLI workers.
 
 CRITICAL IDENTITY:
@@ -331,11 +332,18 @@ export class MasterOrchestrator {
         if (slashResponse) {
             return slashResponse;
         }
+        // Load hub context (AGENTS.md identity, LANDMARKS.md state, project bio if relevant)
+        const hubContext = loadHubContext(message);
+        const hubContextStr = formatHubContext(hubContext);
         // Build context from memory
         const memoryContext = await this.getMemoryContext(message);
-        // Build system prompt with genesis knowledge and memory context
+        // Build system prompt with hub context, genesis knowledge, and memory context
         const genesisKnowledge = getKnowledgeForPrompt();
         let systemWithContext = SYSTEM_PROMPT + genesisKnowledge;
+        // Add hub context (landmarks + project bio)
+        if (hubContextStr) {
+            systemWithContext += `\n\n---\n\nHUB CONTEXT:\n${hubContextStr}`;
+        }
         if (memoryContext) {
             systemWithContext += `\n\nRELEVANT MEMORIES:\n${memoryContext}`;
         }
@@ -348,6 +356,11 @@ export class MasterOrchestrator {
             const response = await this.runAgentLoop(messages, systemWithContext, sendMessage, apiKey);
             // Auto-remember important things from the conversation
             await this.autoRemember(message, response);
+            // Log significant actions to hub
+            if (response.length > 100) {
+                const action = message.length > 50 ? message.slice(0, 50) + '...' : message;
+                logAction(action, hubContext.projectName || undefined, `Response: ${response.length} chars`);
+            }
             return response;
         }
         catch (error) {
@@ -828,197 +841,99 @@ Be specific about what you want done.`,
         }
         return results;
     }
+    // Callback for sending results when worker completes
+    workerResultCallback = null;
+    /**
+     * Set callback for when workers complete (for async notification)
+     */
+    setWorkerResultCallback(callback) {
+        this.workerResultCallback = callback;
+    }
     /**
-     * Delegate task to Claude Code CLI worker with retry logic
-     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
+     * Delegate task to Claude Code CLI worker - NON-BLOCKING
+     * Returns immediately, sends results via callback when done
      */
-    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);
+    async delegateToWorker(task, context, workingDir) {
         const id = `worker_${Date.now()}_${++this.jobCounter}`;
         const cwd = workingDir || this.workspaceDir;
-        // Search for relevant memories to inject into worker prompt
-        let memoryContext = '';
-        try {
-            const relevantMemories = await this.memory.search(task, { limit: 5, minImportance: 0.3 });
-            if (relevantMemories.length > 0) {
-                memoryContext = '\n\nRELEVANT KNOWLEDGE FROM MEMORY:\n' +
-                    relevantMemories.map(m => `[${m.type}] ${m.content}`).join('\n');
-            }
-        }
-        catch (error) {
-            // Memory search failed, continue without it
-            console.log('[ORCHESTRATOR] Memory search failed, continuing without context');
-        }
-        // Get shared state context for worker coordination
-        const sharedContext = this.sharedState.getSummaryForWorker(id);
-        // Build prompt for worker with memory context and checkpoint instructions
+        // Build simple prompt - no bloat
         let prompt = task;
         if (context) {
             prompt = `Context: ${context}\n\nTask: ${task}`;
         }
-        if (memoryContext) {
-            prompt += memoryContext;
-        }
-        if (sharedContext) {
-            prompt += `\n\nWORKER COORDINATION:${sharedContext}`;
-        }
-        // Add checkpoint and logging instructions to prevent data loss
-        const logFile = `/tmp/worker-${id}-log.txt`;
-        prompt += `
-
-IMPORTANT - Progress & Logging:
-- Output findings as you go, don't wait until the end
-- Print discoveries, file paths, and insights immediately as you find them
-- Report on each file/step before moving to the next
-
-REQUIRED - Log Export:
-At the END of your work, create a final log file at: ${logFile}
-Include: job_id=${id}, timestamp, summary of work done, files modified, key findings.
-This ensures nothing is lost even if your output gets truncated.
-
-LEARNING EXPORT (optional but valuable):
-If you discover something important (patterns, user preferences, technical insights),
-end your response with a line like:
-[MEMORY] type=semantic | content=User prefers X over Y for this type of task
-[MEMORY] type=procedural | content=When doing X, always check Y first
-This helps me remember and improve for future tasks.
-
-WORKER COORDINATION (optional):
-If you need to share data with other workers or signal completion:
-[SHARE] key=myData | value={"result": "something useful"}
-[SIGNAL] name=step1_complete | data={"files": ["a.ts", "b.ts"]}
-[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
+        // Add brief instruction
+        prompt += `\n\nBe concise. Output results directly.`;
+        console.log(`[ORCHESTRATOR] Worker ${id} starting: ${task.slice(0, 80)}...`);
+        // Estimate task duration
         const estimatedTime = this.estimateTaskDuration(task);
-        return new Promise((resolve) => {
-            const job = {
-                id,
-                task: task.slice(0, 200),
-                status: 'running',
-                startTime: Date.now(),
-                output: '',
-                estimatedTime
-            };
-            // Escape single quotes in prompt for shell safety
-            // Replace ' with '\'' (end quote, escaped quote, start quote)
-            const escapedPrompt = prompt.replace(/'/g, "'\\''");
-            // Spawn using /bin/bash -l -c to ensure proper PATH resolution (NVM, etc.)
-            // Use absolute path to bash to avoid ENOENT errors in restricted environments
-            const child = spawn('/bin/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);
-            // Configurable timeout (default 30 min, max 60 min)
-            const timeoutMinutes = Math.round(workerTimeout / 60000);
-            const timeout = setTimeout(async () => {
-                if (job.status === 'running') {
-                    job.status = 'timeout';
-                    job.endTime = Date.now();
-                    const duration = Math.round((job.endTime - job.startTime) / 1000);
-                    // Send SIGINT first to allow graceful shutdown and output flush
-                    child.kill('SIGINT');
-                    // Give 5 seconds for graceful shutdown before SIGTERM
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            child.kill('SIGTERM');
-                        }
-                    }, 5000);
-                    // Wait a moment for graceful shutdown to flush logs
-                    await new Promise(r => setTimeout(r, 2000));
-                    const partialOutput = job.output.trim();
-                    // Try to recover from log file
-                    const recoveredLog = this.recoverWorkerLog(id);
-                    // Log failure to memory for learning
-                    await this.logWorkerFailure(id, task, `Timeout after ${timeoutMinutes} minutes`, duration, recoveredLog || undefined);
-                    // Build combined output
-                    let combinedOutput = '';
-                    if (recoveredLog) {
-                        combinedOutput = `[Recovered from log file]\n${recoveredLog}\n\n`;
-                    }
-                    if (partialOutput) {
-                        combinedOutput += `[Partial stdout]\n${partialOutput.slice(-3000)}`;
-                    }
-                    resolve({
-                        success: false,
-                        output: combinedOutput
-                            ? `Worker timed out after ${timeoutMinutes} minutes. Recovered output:\n${combinedOutput}`
-                            : `Worker timed out after ${timeoutMinutes} minutes with no recoverable output.`
-                    });
-                }
-            }, workerTimeout);
-            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', async (code) => {
-                clearTimeout(timeout);
-                job.status = code === 0 ? 'completed' : 'failed';
-                job.endTime = Date.now();
-                const duration = Math.round((job.endTime - job.startTime) / 1000);
-                console.log(`[ORCHESTRATOR] Worker ${id} finished in ${duration}s (code: ${code})`);
-                let finalOutput = job.output.trim();
-                if (code !== 0 || finalOutput.length === 0) {
-                    console.log(`[ORCHESTRATOR] Worker ${id} output: ${finalOutput.slice(0, 200) || '(empty)'}`);
-                    // Try to recover from log file on failure or empty output
-                    const recoveredLog = this.recoverWorkerLog(id);
-                    if (recoveredLog) {
-                        finalOutput = recoveredLog + (finalOutput ? `\n\n[Additional stdout]\n${finalOutput}` : '');
-                    }
-                    // Log failure to memory
-                    if (code !== 0) {
-                        await this.logWorkerFailure(id, task, `Exit code ${code}`, duration, recoveredLog || undefined);
-                    }
-                }
-                // Extract and store memory contributions from worker output
-                await this.extractWorkerMemories(finalOutput, id);
-                resolve({
-                    success: code === 0,
-                    output: finalOutput || '(No output)'
-                });
-            });
-            child.on('error', async (err) => {
-                clearTimeout(timeout);
-                job.status = 'failed';
+        const job = {
+            id,
+            task: task.slice(0, 200),
+            status: 'running',
+            startTime: Date.now(),
+            output: '',
+            estimatedTime
+        };
+        // Escape single quotes in prompt for shell safety
+        const escapedPrompt = prompt.replace(/'/g, "'\\''");
+        // Spawn worker
+        const child = spawn('/bin/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);
+        // 5 minute timeout
+        const timeout = setTimeout(() => {
+            if (job.status === 'running') {
+                job.status = 'timeout';
                 job.endTime = Date.now();
-                const duration = Math.round((job.endTime - job.startTime) / 1000);
-                console.error(`[ORCHESTRATOR] Worker ${id} spawn error:`, err.message);
-                // Retryable errors: ENOENT (command not found), EAGAIN (resource busy), ENOMEM (out of memory)
-                const retryableErrors = ['ENOENT', 'EAGAIN', 'ENOMEM', 'ETIMEDOUT', 'ECONNRESET'];
-                const isRetryable = retryableErrors.some(code => err.message.includes(code));
-                if (isRetryable && retryCount < maxRetries) {
-                    console.log(`[ORCHESTRATOR] Retrying worker (attempt ${retryCount + 2}/${maxRetries + 1}) after ${err.message}...`);
-                    // Exponential backoff: 500ms, 1000ms, 2000ms
-                    const delay = 500 * Math.pow(2, retryCount);
-                    await new Promise(r => setTimeout(r, delay));
-                    const retryResult = await this.delegateToWorker(task, context, workingDir, retryCount + 1, timeoutMs);
-                    resolve(retryResult);
-                    return;
+                child.kill('SIGTERM');
+                console.log(`[ORCHESTRATOR] Worker ${id} timed out`);
+                if (this.workerResultCallback) {
+                    this.workerResultCallback(id, `Worker timed out. Partial output: ${job.output.slice(-1000) || 'none'}`);
                 }
-                // Log failure to memory
-                await this.logWorkerFailure(id, task, err.message, duration);
-                // Try to recover any partial output from log file
-                const recoveredLog = this.recoverWorkerLog(id);
-                resolve({
-                    success: false,
-                    output: recoveredLog
-                        ? `Worker error: ${err.message}\n\n[Recovered from log]\n${recoveredLog}`
-                        : `Worker error: ${err.message}`
-                });
-            });
+            }
+        }, 5 * 60 * 1000);
+        child.stdout?.on('data', (data) => {
+            const text = data.toString();
+            job.output += text;
+            // Stream output to console
+            process.stdout.write(`[${id}] ${text}`);
+        });
+        child.stderr?.on('data', (data) => {
+            const text = data.toString();
+            if (!text.includes('Checking') && !text.includes('Connected')) {
+                job.output += text;
+            }
+        });
+        child.on('close', async (code) => {
+            clearTimeout(timeout);
+            job.status = code === 0 ? 'completed' : 'failed';
+            job.endTime = Date.now();
+            const duration = Math.round((job.endTime - job.startTime) / 1000);
+            console.log(`[ORCHESTRATOR] Worker ${id} done in ${duration}s`);
+            const result = job.output.trim() || '(No output)';
+            // Notify via callback (sends to user via WebSocket)
+            if (this.workerResultCallback) {
+                this.workerResultCallback(id, result);
+            }
         });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            job.status = 'failed';
+            job.endTime = Date.now();
+            console.error(`[ORCHESTRATOR] Worker ${id} error:`, err.message);
+            if (this.workerResultCallback) {
+                this.workerResultCallback(id, `Worker error: ${err.message}`);
+            }
+        });
+        // Return immediately - worker runs in background
+        return {
+            success: true,
+            output: `Worker ${id} started. I'll notify you when it completes.`
+        };
     }
     /**
      * Try to recover worker output from log file

package/package.json

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