@siftd/connect-agent 0.2.56 → 0.2.58

package/dist/orchestrator.d.ts

@@ -75,6 +75,8 @@ export declare class MasterOrchestrator {
     private initialized;
     private currentFileScope;
     private forceTeamWorkingDir;
+    private recentFileWrites;
+    private recentWorkerActivity;
     private bashTool;
     private webTools;
     private workerTools;
@@ -210,7 +212,14 @@ export declare class MasterOrchestrator {
     private getFileScopeOverrides;
     private rewriteFilesAlias;
     private resolveFilesWritePath;
+    private toFilesVirtualPath;
+    private finalizeResponse;
     private getFileScopeSystemNote;
+    private recordWorkerActivity;
+    private formatRelativeTime;
+    private getRecentWorkerSummary;
+    private isStatusInquiry;
+    private buildStatusReply;
     /**
      * Check if verbose mode is enabled
      */

package/dist/orchestrator.js

@@ -258,6 +258,8 @@ export class MasterOrchestrator {
     initialized = false;
     currentFileScope = 'personal';
     forceTeamWorkingDir = false;
+    recentFileWrites = [];
+    recentWorkerActivity = [];
     // New tools from whatsapp-claude
     bashTool;
     webTools;
@@ -937,6 +939,52 @@ export class MasterOrchestrator {
         }
         return resolved;
     }
+    toFilesVirtualPath(rawPath, resolvedPath) {
+        const trimmed = rawPath.trim();
+        if (!trimmed)
+            return '/files';
+        const lower = trimmed.toLowerCase();
+        if (lower.startsWith('/files')) {
+            const suffix = trimmed.slice('/files'.length).replace(/\\/g, '/');
+            return `/files${suffix}`;
+        }
+        if (lower.startsWith('files/')) {
+            const suffix = trimmed.slice('files'.length).replace(/\\/g, '/');
+            return `/files${suffix}`;
+        }
+        if (trimmed.startsWith('/')) {
+            const teamDir = this.currentFileScope === 'team' ? this.getTeamFilesDir() : null;
+            const baseDir = teamDir || getSharedOutputPath();
+            try {
+                const resolved = resolve(resolvedPath || trimmed);
+                const baseResolved = resolve(baseDir);
+                if (resolved === baseResolved)
+                    return '/files';
+                if (resolved.startsWith(`${baseResolved}${sep}`)) {
+                    const rel = resolved.slice(baseResolved.length + 1).replace(/\\/g, '/');
+                    return `/files/${rel}`;
+                }
+            }
+            catch {
+                return '/files';
+            }
+        }
+        const cleaned = trimmed.replace(/^\/+/, '').replace(/^files\/?/i, '');
+        return cleaned ? `/files/${cleaned}` : '/files';
+    }
+    finalizeResponse(text) {
+        const trimmed = text.trim();
+        if (this.recentFileWrites.length === 0)
+            return trimmed || text;
+        const uniquePaths = Array.from(new Set(this.recentFileWrites));
+        const confirmation = uniquePaths.length === 1
+            ? `Saved ${uniquePaths[0]}.`
+            : `Saved files:\n${uniquePaths.map((path) => `- ${path}`).join('\n')}`;
+        if (!trimmed)
+            return confirmation;
+        const mentionsPath = uniquePaths.some((path) => trimmed.includes(path)) || /\/files\b/i.test(trimmed);
+        return mentionsPath ? trimmed : `${trimmed}\n\n${confirmation}`;
+    }
     getFileScopeSystemNote() {
         if (this.currentFileScope !== 'team')
             return null;
@@ -945,6 +993,98 @@ export class MasterOrchestrator {
             return null;
         return `TEAM FILES DIRECTORY:\n- ${teamDir}\nUse this path for files meant to be shared with the team.`;
     }
+    recordWorkerActivity(event) {
+        const normalized = {
+            ...event,
+            task: event.task.slice(0, 140),
+            note: event.note?.slice(0, 200)
+        };
+        this.recentWorkerActivity = [normalized, ...this.recentWorkerActivity].slice(0, 12);
+    }
+    formatRelativeTime(timestamp) {
+        const deltaMs = Date.now() - timestamp;
+        if (deltaMs < 1000)
+            return 'just now';
+        const seconds = Math.floor(deltaMs / 1000);
+        if (seconds < 60)
+            return `${seconds}s ago`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60)
+            return `${minutes}m ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24)
+            return `${hours}h ago`;
+        const days = Math.floor(hours / 24);
+        return `${days}d ago`;
+    }
+    getRecentWorkerSummary(limit = 4) {
+        if (this.recentWorkerActivity.length === 0)
+            return null;
+        const seen = new Set();
+        const lines = [];
+        for (const event of this.recentWorkerActivity) {
+            if (seen.has(event.id))
+                continue;
+            seen.add(event.id);
+            const when = this.formatRelativeTime(event.endedAt ?? event.startedAt);
+            const note = event.note ? ` — ${event.note}` : '';
+            lines.push(`- ${event.task} (${event.status}, ${when})${note}`);
+            if (lines.length >= limit)
+                break;
+        }
+        return lines.length > 0 ? lines.join('\n') : null;
+    }
+    isStatusInquiry(message) {
+        const lower = message.toLowerCase();
+        if (!lower)
+            return false;
+        const patterns = [
+            /\b(status|progress|queue|queued|pending)\b/,
+            /\bwhat (are|were) you (doing|working on)\b/,
+            /\bwhat happened\b/,
+            /\bstuck\b/,
+            /\btaking (so long|forever|too long)\b/,
+            /\bwhy (is|are) (this|it) (taking|hung|stuck)\b/,
+        ];
+        return patterns.some((pattern) => pattern.test(lower));
+    }
+    buildStatusReply() {
+        const queueStatus = this.taskQueue.getStatus();
+        const runningWorkers = this.getWorkerStatus().filter((worker) => worker.status === 'running');
+        const recentWorkers = this.getRecentWorkerSummary(4);
+        const recentTasks = this.taskQueue.getRecentTasks(3)
+            .filter((task) => task.status !== 'pending')
+            .map((task) => `- ${task.content.slice(0, 80)} (${task.status})`);
+        const lines = [];
+        if (runningWorkers.length > 0) {
+            lines.push(`Active workers: ${runningWorkers.length}`);
+            for (const worker of runningWorkers.slice(0, 3)) {
+                lines.push(`- ${worker.task} (${worker.progress}% · ${worker.elapsed}s)`);
+            }
+        }
+        else {
+            lines.push('Active workers: none');
+        }
+        if (queueStatus.isProcessing || queueStatus.pendingCount > 0) {
+            const current = queueStatus.currentTask?.content;
+            lines.push(`Task queue: ${queueStatus.pendingCount} pending${queueStatus.isProcessing ? ' · processing' : ''}`);
+            if (current) {
+                lines.push(`- Current: ${current.slice(0, 100)}`);
+            }
+        }
+        else {
+            lines.push('Task queue: empty');
+        }
+        if (recentWorkers) {
+            lines.push('Recent worker activity:');
+            lines.push(recentWorkers);
+        }
+        if (recentTasks.length > 0) {
+            lines.push('Recent task results:');
+            lines.push(recentTasks.join('\n'));
+        }
+        return lines.join('\n');
+    }
     /**
      * Check if verbose mode is enabled
      */
@@ -963,6 +1103,9 @@ export class MasterOrchestrator {
             return slashResponse;
         }
         this.updateFileScope(cleanMessage);
+        if (this.isStatusInquiry(cleanMessage)) {
+            return this.buildStatusReply();
+        }
         const wantsTodoOrCal = this.hasTodoMutation(cleanMessage) || this.hasCalendarMutation(cleanMessage);
         if (wantsTodoOrCal) {
             this.attachmentContext = this.extractAttachmentContext(message);
@@ -1019,6 +1162,10 @@ ${hubContextStr}
         if (fileScopeNote) {
             systemWithContext += `\n\n${fileScopeNote}`;
         }
+        const recentWorkerSummary = this.getRecentWorkerSummary();
+        if (recentWorkerSummary) {
+            systemWithContext += `\n\nRECENT WORKER ACTIVITY (for accurate status updates):\n${recentWorkerSummary}`;
+        }
         // Add user message
         const messages = [
             ...conversationHistory,
@@ -1454,6 +1601,7 @@ ${hubContextStr}
         const forcedToolChoice = this.getToolChoice(currentMessages);
         let retriedForcedTool = false;
         let retriedTodoCal = false;
+        this.recentFileWrites = [];
         while (iterations < maxIterations) {
             iterations++;
             const toolChoice = forcedToolChoice ?? this.getToolChoice(currentMessages);
@@ -1516,7 +1664,7 @@ ${hubContextStr}
                     ];
                     continue;
                 }
-                return this.extractText(response.content);
+                return this.finalizeResponse(this.extractText(response.content));
             }
             const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
             const toolNames = toolUseBlocks.map((block) => block.name);
@@ -1554,7 +1702,7 @@ ${hubContextStr}
                 { role: 'user', content: toolResults }
             ];
         }
-        return 'Maximum iterations reached.';
+        return this.finalizeResponse('Maximum iterations reached.');
     }
     /**
      * Get tool definitions for the orchestrator
@@ -2258,7 +2406,9 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
                                 const targetPath = this.resolveFilesWritePath(pathValue);
                                 mkdirSync(dirname(targetPath), { recursive: true });
                                 writeFileSync(targetPath, content, 'utf8');
-                                result = { success: true, output: 'Saved file to /files.' };
+                                const virtualPath = this.toFilesVirtualPath(pathValue, targetPath);
+                                this.recentFileWrites.push(virtualPath);
+                                result = { success: true, output: `Saved file to ${virtualPath}.` };
                             }
                             catch (error) {
                                 const message = error instanceof Error ? error.message : String(error);
@@ -2286,6 +2436,17 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
                             priority: input.priority,
                             workingDirectory: input.working_directory || fileScope.workingDir
                         });
+                        if (result.success && result.output) {
+                            const match = result.output.match(/Job ID:\s*(\S+)/i);
+                            if (match) {
+                                this.recordWorkerActivity({
+                                    id: match[1],
+                                    task: normalizedTask.slice(0, 200),
+                                    status: 'running',
+                                    startedAt: Date.now(),
+                                });
+                            }
+                        }
                         break;
                     }
                     case 'check_worker':
@@ -2299,6 +2460,16 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
                         break;
                     case 'cancel_worker':
                         result = await this.workerTools.cancelWorker(input.job_id);
+                        if (result.success) {
+                            this.recordWorkerActivity({
+                                id: String(input.job_id || 'unknown'),
+                                task: 'Worker cancelled',
+                                status: 'cancelled',
+                                startedAt: Date.now(),
+                                endedAt: Date.now(),
+                                note: 'Cancelled by request'
+                            });
+                        }
                         break;
                     // Legacy delegate tool
                     case 'delegate_to_worker': {
@@ -2459,6 +2630,12 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
             estimatedTime,
             workingDir: cwd
         };
+        this.recordWorkerActivity({
+            id,
+            task: job.task,
+            status: 'running',
+            startedAt: job.startTime
+        });
         // Escape single quotes in prompt for shell safety
         const escapedPrompt = prompt.replace(/'/g, "'\\''");
         const budget = resolveClaudeBudgetUsd();
@@ -2499,6 +2676,14 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
                 job.endTime = Date.now();
                 child.kill('SIGTERM');
                 console.log(`[ORCHESTRATOR] Worker ${id} timed out`);
+                this.recordWorkerActivity({
+                    id,
+                    task: job.task,
+                    status: 'timeout',
+                    startedAt: job.startTime,
+                    endedAt: job.endTime,
+                    note: 'Timed out after 5 minutes'
+                });
                 if (this.workerResultCallback) {
                     this.workerResultCallback(id, `Worker timed out. Partial output: ${job.output.slice(-1000) || 'none'}`);
                 }
@@ -2536,6 +2721,14 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
             const status = code === 0 ? 'completed' : 'failed';
             const filesCreated = assets.map(a => a.name);
             logWorker(id, job.task, status, duration, filesCreated.length > 0 ? filesCreated : undefined);
+            this.recordWorkerActivity({
+                id,
+                task: job.task,
+                status,
+                startedAt: job.startTime,
+                endedAt: job.endTime,
+                note: code === 0 ? undefined : `Exit code ${code ?? 'unknown'}`
+            });
             if (assets.length > 0) {
                 console.log(`[ORCHESTRATOR] Worker ${id} created ${assets.length} files: ${assets.map(a => a.name).join(', ')}`);
                 // Store in memory for gallery queries
@@ -2563,6 +2756,14 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
             job.status = 'failed';
             job.endTime = Date.now();
             console.error(`[ORCHESTRATOR] Worker ${id} error:`, err.message);
+            this.recordWorkerActivity({
+                id,
+                task: job.task,
+                status: 'failed',
+                startedAt: job.startTime,
+                endedAt: job.endTime,
+                note: err.message
+            });
             if (this.workerResultCallback) {
                 this.workerResultCallback(id, `Worker error: ${err.message}`);
             }

package/package.json

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