@hexidecibel/companion 0.0.1 → 0.1.1

package/dist/websocket.js

@@ -40,6 +40,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
 const tmux_manager_1 = require("./tmux-manager");
 const parser_1 = require("./parser");
 const config_1 = require("./config");
@@ -47,6 +48,8 @@ const anthropic_usage_1 = require("./anthropic-usage");
 const tool_config_1 = require("./tool-config");
 const templates_1 = require("./scaffold/templates");
 const generator_1 = require("./scaffold/generator");
+const scorer_1 = require("./scaffold/scorer");
+const escalation_1 = require("./escalation");
 // File for persisting tmux session configs
 const TMUX_CONFIGS_FILE = path.join(os.homedir(), '.companion', 'tmux-sessions.json');
 class WebSocketHandler {
@@ -64,15 +67,19 @@ class WebSocketHandler {
     MAX_CLIENT_ERRORS = 50;
     scrollLogs = [];
     MAX_SCROLL_LOGS = 200;
-    autoApproveEnabled = false;
-    constructor(server, config, watcher, injector, push, tmux, subAgentWatcher) {
+    autoApproveSessions = new Set();
+    escalation;
+    workGroupManager;
+    constructor(server, config, watcher, injector, push, tmux, subAgentWatcher, workGroupManager) {
         this.config = config;
         this.token = config.token;
         this.watcher = watcher;
         this.subAgentWatcher = subAgentWatcher || null;
+        this.workGroupManager = workGroupManager || null;
         this.injector = injector;
         this.push = push;
         this.tmux = tmux || new tmux_manager_1.TmuxManager('companion');
+        this.escalation = new escalation_1.EscalationService(this.push.getStore(), this.push);
         this.wss = new ws_1.WebSocketServer({ server });
         this.wss.on('connection', (ws, req) => this.handleConnection(ws, req));
         // Forward watcher events to subscribed clients
@@ -81,12 +88,22 @@ class WebSocketHandler {
         });
         this.watcher.on('status-change', (data) => {
             this.broadcast('status_change', data);
-            // Schedule push notification if waiting for input (include session info)
+            // Escalation for waiting_for_input
             if (data.isWaitingForInput && data.lastMessage) {
-                this.push.scheduleWaitingNotification(data.lastMessage.content, data.sessionId || undefined, this.injector.getActiveSession() || undefined);
+                const event = {
+                    eventType: 'waiting_for_input',
+                    sessionId: data.sessionId || 'unknown',
+                    sessionName: this.injector.getActiveSession() || 'unknown',
+                    content: data.lastMessage.content,
+                };
+                const result = this.escalation.handleEvent(event);
+                if (result.shouldBroadcast) {
+                    console.log(`Escalation: waiting_for_input broadcast for session "${event.sessionName}"`);
+                }
             }
-            else {
-                this.push.cancelPendingNotification();
+            else if (!data.isWaitingForInput && data.sessionId) {
+                // Session stopped waiting — acknowledge (cancel pending push)
+                this.escalation.acknowledgeSession(data.sessionId);
             }
         });
         // Notify about activity in other (non-active) sessions
@@ -97,6 +114,29 @@ class WebSocketHandler {
         this.watcher.on('compaction', (data) => {
             this.broadcast('compaction', data);
         });
+        // Escalation-based notifications for error-detected and session-completed
+        const handleEscalationEvent = (eventType, data) => {
+            const event = {
+                eventType,
+                sessionId: data.sessionId,
+                sessionName: data.sessionName,
+                content: data.content,
+            };
+            const result = this.escalation.handleEvent(event);
+            if (result.shouldBroadcast) {
+                console.log(`Escalation: ${eventType} broadcast for session "${data.sessionName}"`);
+            }
+            // Always broadcast the event to connected web clients
+            this.broadcast(eventType, data);
+        };
+        this.watcher.on('error-detected', (data) => handleEscalationEvent('error_detected', data));
+        this.watcher.on('session-completed', (data) => handleEscalationEvent('session_completed', data));
+        // Forward work group updates to clients
+        if (this.workGroupManager) {
+            this.workGroupManager.on('work-group-update', (group) => {
+                this.broadcast('work_group_update', group);
+            });
+        }
         // Load saved tmux session configs
         this.loadTmuxSessionConfigs();
         console.log('WebSocket: Server initialized');
@@ -139,7 +179,7 @@ class WebSocketHandler {
         this.saveTmuxSessionConfigs();
         console.log(`WebSocket: Stored tmux session config for "${name}" (${workingDir})`);
     }
-    handleConnection(ws, req) {
+    handleConnection(ws, _req) {
         const clientId = (0, uuid_1.v4)();
         const client = {
             id: clientId,
@@ -175,7 +215,6 @@ class WebSocketHandler {
     }
     handleMessage(client, message) {
         const { type, token, payload, requestId } = message;
-        const reqStart = Date.now();
         if (type !== 'ping') {
             console.log(`WebSocket: >> recv ${type} (${requestId || 'no-id'}) from ${client.id}`);
         }
@@ -243,23 +282,39 @@ class WebSocketHandler {
             case 'get_highlights': {
                 const hlParams = payload;
                 const t0 = Date.now();
-                const messages = this.watcher.getMessages();
-                const t1 = Date.now();
-                const allHighlights = (0, parser_1.extractHighlights)(messages);
-                const t2 = Date.now();
                 const hlSessionId = this.watcher.getActiveSessionId();
-                const total = allHighlights.length;
-                // Paginate: return most recent `limit` items, with optional offset from end
-                let resultHighlights = allHighlights;
-                let hasMore = false;
-                if (hlParams?.limit && hlParams.limit > 0) {
-                    const offset = hlParams.offset || 0;
-                    const startIdx = Math.max(0, total - offset - hlParams.limit);
-                    const endIdx = total - offset;
-                    resultHighlights = allHighlights.slice(startIdx, endIdx);
-                    hasMore = startIdx > 0;
+                const limit = hlParams?.limit && hlParams.limit > 0 ? hlParams.limit : 0;
+                const offset = hlParams?.offset || 0;
+                // Use conversation chain for cross-session infinite scroll
+                const chain = hlSessionId ? this.watcher.getConversationChain(hlSessionId) : [];
+                let resultHighlights;
+                let total;
+                let hasMore;
+                if (chain.length > 1 && limit > 0) {
+                    // Multiple files — use chain-aware pagination
+                    const result = (0, parser_1.parseConversationChain)(chain, limit, offset);
+                    resultHighlights = result.highlights;
+                    total = result.total;
+                    hasMore = result.hasMore;
+                }
+                else {
+                    // Single file or no limit — use existing fast path
+                    const messages = this.watcher.getMessages();
+                    const allHighlights = (0, parser_1.extractHighlights)(messages);
+                    total = allHighlights.length;
+                    if (limit > 0) {
+                        const startIdx = Math.max(0, total - offset - limit);
+                        const endIdx = total - offset;
+                        resultHighlights = allHighlights.slice(startIdx, endIdx);
+                        hasMore = startIdx > 0;
+                    }
+                    else {
+                        resultHighlights = allHighlights;
+                        hasMore = false;
+                    }
                 }
-                console.log(`WebSocket: get_highlights - getMessages: ${t1 - t0}ms, extractHighlights: ${t2 - t1}ms, ${messages.length} msgs, returning ${resultHighlights.length}/${total}`);
+                const t1 = Date.now();
+                console.log(`WebSocket: get_highlights - ${t1 - t0}ms, chain: ${chain.length} files, returning ${resultHighlights.length}/${total}`);
                 this.send(client.ws, {
                     type: 'highlights',
                     success: true,
@@ -289,7 +344,7 @@ class WebSocketHandler {
                 const status = this.watcher.getStatus();
                 const t1 = Date.now();
                 const statusSessionId = this.watcher.getActiveSessionId();
-                console.log(`WebSocket: get_status - ${t1 - t0}ms`);
+                console.log(`WebSocket: get_status - ${t1 - t0}ms - waiting: ${status.isWaitingForInput}, running: ${status.isRunning}, session: ${statusSessionId}`);
                 this.send(client.ws, {
                     type: 'status',
                     success: true,
@@ -301,7 +356,9 @@ class WebSocketHandler {
             }
             case 'get_server_summary':
                 // Get tmux sessions to filter - only show conversations with active tmux sessions
-                this.tmux.listSessions().then(async (tmuxSessions) => {
+                this.tmux
+                    .listSessions()
+                    .then(async (tmuxSessions) => {
                     const summary = await this.watcher.getServerSummary(tmuxSessions);
                     this.send(client.ws, {
                         type: 'server_summary',
@@ -309,7 +366,8 @@ class WebSocketHandler {
                         payload: summary,
                         requestId,
                     });
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     console.error('Failed to get server summary:', err);
                     this.send(client.ws, {
                         type: 'server_summary',
@@ -335,7 +393,7 @@ class WebSocketHandler {
                 const tasksSessionId = tasksPayload?.sessionId || this.watcher.getActiveSessionId();
                 if (tasksSessionId) {
                     const sessionSessions = this.watcher.getSessions();
-                    const session = sessionSessions.find(s => s.id === tasksSessionId);
+                    const session = sessionSessions.find((s) => s.id === tasksSessionId);
                     if (session?.conversationPath) {
                         try {
                             const fs = require('fs');
@@ -378,9 +436,23 @@ class WebSocketHandler {
             case 'switch_session':
                 // Handle switch_session asynchronously but await completion
                 this.handleSwitchSession(client, payload, requestId);
+                // Acknowledge session — user is viewing it, cancel push escalation
+                {
+                    const switchPayload = payload;
+                    if (switchPayload?.sessionId) {
+                        this.escalation.acknowledgeSession(switchPayload.sessionId);
+                    }
+                }
                 break;
             case 'send_input':
                 this.handleSendInput(client, payload, requestId);
+                // Acknowledge session — user is responding, cancel push escalation
+                {
+                    const activeSessionId = this.watcher.getActiveSessionId();
+                    if (activeSessionId) {
+                        this.escalation.acknowledgeSession(activeSessionId);
+                    }
+                }
                 break;
             case 'send_image':
                 this.handleSendImage(client, payload, requestId);
@@ -427,66 +499,33 @@ class WebSocketHandler {
                     });
                 }
                 break;
-            case 'set_instant_notify':
-                const instantPayload = payload;
-                if (client.deviceId) {
-                    this.push.setInstantNotify(client.deviceId, instantPayload?.enabled ?? false);
-                    this.send(client.ws, {
-                        type: 'instant_notify_set',
-                        success: true,
-                        payload: { enabled: instantPayload?.enabled ?? false },
-                        requestId,
-                    });
-                }
-                else {
-                    this.send(client.ws, {
-                        type: 'instant_notify_set',
-                        success: false,
-                        error: 'Device not registered for push',
-                        requestId,
-                    });
-                }
-                break;
+            // set_instant_notify removed — escalation model replaces per-device instant notify
             case 'set_auto_approve': {
                 const autoApprovePayload = payload;
-                this.autoApproveEnabled = autoApprovePayload?.enabled ?? false;
-                console.log(`Auto-approve ${this.autoApproveEnabled ? 'enabled' : 'disabled'} by client`);
+                const targetSessionId = autoApprovePayload?.sessionId || this.watcher.getActiveSessionId();
+                const enabled = autoApprovePayload?.enabled ?? false;
+                if (targetSessionId) {
+                    if (enabled) {
+                        this.autoApproveSessions.add(targetSessionId);
+                    }
+                    else {
+                        this.autoApproveSessions.delete(targetSessionId);
+                    }
+                    console.log(`Auto-approve ${enabled ? 'enabled' : 'disabled'} for session ${targetSessionId} (${this.autoApproveSessions.size} sessions active)`);
+                }
                 this.send(client.ws, {
                     type: 'auto_approve_set',
                     success: true,
-                    payload: { enabled: this.autoApproveEnabled },
+                    payload: { enabled, sessionId: targetSessionId },
                     requestId,
                 });
                 // When toggled ON, immediately check for pending tools that should be auto-approved
-                if (this.autoApproveEnabled) {
+                if (enabled) {
                     this.watcher.checkAndEmitPendingApproval();
                 }
                 break;
             }
-            case 'set_notification_prefs':
-                const notifPrefs = payload;
-                if (client.deviceId) {
-                    this.push.setNotificationPrefs(client.deviceId, {
-                        quietHoursEnabled: notifPrefs?.quietHoursEnabled ?? false,
-                        quietHoursStart: notifPrefs?.quietHoursStart ?? '22:00',
-                        quietHoursEnd: notifPrefs?.quietHoursEnd ?? '08:00',
-                        throttleMinutes: notifPrefs?.throttleMinutes ?? 0,
-                    });
-                    this.send(client.ws, {
-                        type: 'notification_prefs_set',
-                        success: true,
-                        requestId,
-                    });
-                }
-                else {
-                    this.send(client.ws, {
-                        type: 'notification_prefs_set',
-                        success: false,
-                        error: 'Device not registered for push',
-                        requestId,
-                    });
-                }
-                break;
+            // set_notification_prefs removed — escalation config replaces per-device prefs
             case 'ping':
                 if (client.deviceId) {
                     this.push.updateDeviceLastSeen(client.deviceId);
@@ -508,7 +547,8 @@ class WebSocketHandler {
             case 'get_terminal_output': {
                 const termPayload = payload;
                 if (termPayload?.sessionName) {
-                    this.tmux.capturePane(termPayload.sessionName, termPayload.lines || 100)
+                    this.tmux
+                        .capturePane(termPayload.sessionName, termPayload.lines || 100)
                         .then((output) => {
                         this.send(client.ws, {
                             type: 'terminal_output',
@@ -536,6 +576,38 @@ class WebSocketHandler {
                 }
                 break;
             }
+            case 'send_terminal_keys': {
+                const termKeysPayload = payload;
+                if (termKeysPayload?.sessionName && termKeysPayload.keys?.length) {
+                    this.tmux
+                        .sendRawKeys(termKeysPayload.sessionName, termKeysPayload.keys)
+                        .then((ok) => {
+                        this.send(client.ws, {
+                            type: 'terminal_keys_sent',
+                            success: ok,
+                            error: ok ? undefined : 'Failed to send keys',
+                            requestId,
+                        });
+                    })
+                        .catch(() => {
+                        this.send(client.ws, {
+                            type: 'terminal_keys_sent',
+                            success: false,
+                            error: 'Failed to send terminal keys',
+                            requestId,
+                        });
+                    });
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'terminal_keys_sent',
+                        success: false,
+                        error: 'Missing sessionName or keys',
+                        requestId,
+                    });
+                }
+                break;
+            }
             case 'get_tool_config':
                 this.send(client.ws, {
                     type: 'tool_config',
@@ -556,12 +628,21 @@ class WebSocketHandler {
             case 'recreate_tmux_session':
                 this.handleRecreateTmuxSession(client, payload, requestId);
                 break;
+            case 'create_worktree_session':
+                this.handleCreateWorktreeSession(client, payload, requestId);
+                break;
+            case 'list_worktrees':
+                this.handleListWorktrees(client, payload, requestId);
+                break;
             case 'browse_directories':
                 this.handleBrowseDirectories(client, payload, requestId);
                 break;
             case 'read_file':
                 this.handleReadFile(client, payload, requestId);
                 break;
+            case 'open_in_editor':
+                this.handleOpenInEditor(client, payload, requestId);
+                break;
             case 'download_file':
                 this.handleDownloadFile(client, payload, requestId);
                 break;
@@ -594,24 +675,84 @@ class WebSocketHandler {
                 this.scrollLogs = [];
                 this.send(client.ws, { type: 'scroll_logs_cleared', success: true, requestId });
                 break;
+            // Work Group endpoints
+            case 'spawn_work_group':
+                this.handleSpawnWorkGroup(client, payload, requestId);
+                break;
+            case 'get_work_groups':
+                this.handleGetWorkGroups(client, requestId);
+                break;
+            case 'get_work_group':
+                this.handleGetWorkGroup(client, payload, requestId);
+                break;
+            case 'merge_work_group':
+                this.handleMergeWorkGroup(client, payload, requestId);
+                break;
+            case 'cancel_work_group':
+                this.handleCancelWorkGroup(client, payload, requestId);
+                break;
+            case 'retry_worker':
+                this.handleRetryWorker(client, payload, requestId);
+                break;
+            case 'send_worker_input':
+                this.handleSendWorkerInput(client, payload, requestId);
+                break;
+            case 'dismiss_work_group':
+                this.handleDismissWorkGroup(client, payload, requestId);
+                break;
             // Scaffold endpoints
-            case 'get_scaffold_templates':
-                this.send(client.ws, {
-                    type: 'scaffold_templates',
-                    success: true,
-                    payload: {
-                        templates: templates_1.templates.map(t => ({
-                            id: t.id,
-                            name: t.name,
-                            description: t.description,
-                            type: t.type,
-                            icon: t.icon,
-                            tags: t.tags,
-                        })),
-                    },
-                    requestId,
-                });
+            case 'get_scaffold_templates': {
+                const scaffoldPayload = payload;
+                const description = scaffoldPayload?.description;
+                if (description && description.trim()) {
+                    const scores = (0, scorer_1.scoreTemplates)(templates_1.templates, description);
+                    const scoreMap = new Map(scores.map((s) => [s.templateId, s]));
+                    // Sort templates by score descending
+                    const sorted = [...templates_1.templates].sort((a, b) => {
+                        const sa = scoreMap.get(a.id)?.score ?? 0;
+                        const sb = scoreMap.get(b.id)?.score ?? 0;
+                        return sb - sa;
+                    });
+                    this.send(client.ws, {
+                        type: 'scaffold_templates',
+                        success: true,
+                        payload: {
+                            templates: sorted.map((t) => {
+                                const s = scoreMap.get(t.id);
+                                return {
+                                    id: t.id,
+                                    name: t.name,
+                                    description: t.description,
+                                    type: t.type,
+                                    icon: t.icon,
+                                    tags: t.tags,
+                                    score: s?.score ?? 0,
+                                    matchedKeywords: s?.matchedKeywords ?? [],
+                                };
+                            }),
+                        },
+                        requestId,
+                    });
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'scaffold_templates',
+                        success: true,
+                        payload: {
+                            templates: templates_1.templates.map((t) => ({
+                                id: t.id,
+                                name: t.name,
+                                description: t.description,
+                                type: t.type,
+                                icon: t.icon,
+                                tags: t.tags,
+                            })),
+                        },
+                        requestId,
+                    });
+                }
                 break;
+            }
             case 'scaffold_preview':
                 (async () => {
                     const previewConfig = payload;
@@ -624,6 +765,153 @@ class WebSocketHandler {
                     });
                 })();
                 break;
+            // Escalation config endpoints (replaces notification rules CRUD)
+            case 'get_escalation_config': {
+                const store = this.push.getStore();
+                this.send(client.ws, {
+                    type: 'escalation_config',
+                    success: true,
+                    payload: { config: store.getEscalation() },
+                    requestId,
+                });
+                break;
+            }
+            case 'update_escalation_config': {
+                const configPayload = payload;
+                const store = this.push.getStore();
+                const updated = store.setEscalation(configPayload);
+                this.send(client.ws, {
+                    type: 'escalation_config_updated',
+                    success: true,
+                    payload: { config: updated },
+                    requestId,
+                });
+                break;
+            }
+            case 'get_pending_events': {
+                const events = this.escalation.getPendingEvents();
+                this.send(client.ws, {
+                    type: 'pending_events',
+                    success: true,
+                    payload: { events },
+                    requestId,
+                });
+                break;
+            }
+            // Device management
+            case 'get_devices': {
+                const store = this.push.getStore();
+                this.send(client.ws, {
+                    type: 'devices',
+                    success: true,
+                    payload: { devices: store.getDevices() },
+                    requestId,
+                });
+                break;
+            }
+            case 'remove_device': {
+                const removePayload = payload;
+                if (!removePayload?.deviceId) {
+                    this.send(client.ws, {
+                        type: 'device_removed',
+                        success: false,
+                        error: 'Missing deviceId',
+                        requestId,
+                    });
+                    break;
+                }
+                const store = this.push.getStore();
+                const removed = store.removeDevice(removePayload.deviceId);
+                this.send(client.ws, {
+                    type: 'device_removed',
+                    success: removed,
+                    error: removed ? undefined : 'Device not found',
+                    requestId,
+                });
+                break;
+            }
+            // Session muting
+            case 'set_session_muted': {
+                const mutePayload = payload;
+                if (!mutePayload?.sessionId || mutePayload.muted === undefined) {
+                    this.send(client.ws, {
+                        type: 'session_muted_set',
+                        success: false,
+                        error: 'Missing sessionId or muted',
+                        requestId,
+                    });
+                    break;
+                }
+                const store = this.push.getStore();
+                store.setSessionMuted(mutePayload.sessionId, mutePayload.muted);
+                this.send(client.ws, {
+                    type: 'session_muted_set',
+                    success: true,
+                    payload: { sessionId: mutePayload.sessionId, muted: mutePayload.muted },
+                    requestId,
+                });
+                // Broadcast to all clients so mute state is visible everywhere
+                this.broadcast('session_mute_changed', {
+                    sessionId: mutePayload.sessionId,
+                    muted: mutePayload.muted,
+                });
+                break;
+            }
+            case 'get_muted_sessions': {
+                const store = this.push.getStore();
+                this.send(client.ws, {
+                    type: 'muted_sessions',
+                    success: true,
+                    payload: { sessionIds: store.getMutedSessions() },
+                    requestId,
+                });
+                break;
+            }
+            // Notification history
+            case 'get_notification_history': {
+                const histPayload = payload;
+                const store = this.push.getStore();
+                const history = store.getHistory(histPayload?.limit);
+                this.send(client.ws, {
+                    type: 'notification_history',
+                    success: true,
+                    payload: history,
+                    requestId,
+                });
+                break;
+            }
+            case 'clear_notification_history': {
+                const store = this.push.getStore();
+                store.clearHistory();
+                this.send(client.ws, {
+                    type: 'notification_history_cleared',
+                    success: true,
+                    requestId,
+                });
+                break;
+            }
+            case 'send_test_notification': {
+                (async () => {
+                    try {
+                        const result = await this.push.sendTestNotification();
+                        this.send(client.ws, {
+                            type: 'test_notification_sent',
+                            success: true,
+                            payload: result,
+                            requestId,
+                        });
+                    }
+                    catch (err) {
+                        this.send(client.ws, {
+                            type: 'test_notification_sent',
+                            success: false,
+                            error: String(err),
+                            requestId,
+                        });
+                    }
+                })();
+                break;
+            }
             case 'scaffold_create':
                 (async () => {
                     try {
@@ -676,8 +964,6 @@ class WebSocketHandler {
             });
             return;
         }
-        // Cancel any pending push notification since user is responding
-        this.push.cancelPendingNotification();
         // Check if the target session exists before trying to send
         const activeSession = this.injector.getActiveSession();
         const sessionExists = await this.injector.checkSessionExists(activeSession);
@@ -691,10 +977,12 @@ class WebSocketHandler {
                 payload: {
                     sessionName: activeSession,
                     canRecreate: !!savedConfig,
-                    savedConfig: savedConfig ? {
-                        name: savedConfig.name,
-                        workingDir: savedConfig.workingDir,
-                    } : undefined,
+                    savedConfig: savedConfig
+                        ? {
+                            name: savedConfig.name,
+                            workingDir: savedConfig.workingDir,
+                        }
+                        : undefined,
                 },
                 requestId,
             });
@@ -727,8 +1015,6 @@ class WebSocketHandler {
             const buffer = Buffer.from(payload.base64, 'base64');
             fs.writeFileSync(filepath, buffer);
             console.log(`Image saved to: ${filepath}`);
-            // Cancel any pending push notification
-            this.push.cancelPendingNotification();
             // Send the file path to the coding session
             const success = await this.injector.sendInput(`Please look at this image: ${filepath}`);
             this.send(client.ws, {
@@ -793,8 +1079,6 @@ class WebSocketHandler {
             });
             return;
         }
-        // Cancel any pending push notification
-        this.push.cancelPendingNotification();
         // Build combined message: image paths + user message
         const parts = [];
         if (payload.imagePaths && payload.imagePaths.length > 0) {
@@ -856,10 +1140,10 @@ class WebSocketHandler {
         // 3. Find and switch to corresponding tmux session
         let tmuxSessionName;
         try {
-            const convSession = this.watcher.getSessions().find(s => s.id === sessionId);
+            const convSession = this.watcher.getSessions().find((s) => s.id === sessionId);
             if (convSession?.projectPath) {
                 const tmuxSessions = await this.tmux.listSessions();
-                const matchingTmux = tmuxSessions.find(ts => ts.workingDir === convSession.projectPath);
+                const matchingTmux = tmuxSessions.find((ts) => ts.workingDir === convSession.projectPath);
                 if (matchingTmux) {
                     this.injector.setActiveSession(matchingTmux.name);
                     tmuxSessionName = matchingTmux.name;
@@ -1019,6 +1303,12 @@ class WebSocketHandler {
         console.log(`WebSocket: Killing tmux session "${payload.sessionName}"`);
         const result = await this.tmux.killSession(payload.sessionName);
         if (result.success) {
+            // If this was a worktree session, clean up the worktree
+            const config = this.tmuxSessionConfigs.get(payload.sessionName);
+            if (config?.isWorktree && config.mainRepoDir) {
+                console.log(`WebSocket: Cleaning up worktree at ${config.workingDir}`);
+                await this.tmux.removeWorktree(config.mainRepoDir, config.workingDir);
+            }
             // If we killed the active session, switch to another
             if (this.injector.getActiveSession() === payload.sessionName) {
                 const remaining = await this.tmux.listSessions();
@@ -1033,7 +1323,10 @@ class WebSocketHandler {
                 requestId,
             });
             // Broadcast to all clients
-            this.broadcast('tmux_sessions_changed', { action: 'killed', sessionName: payload.sessionName });
+            this.broadcast('tmux_sessions_changed', {
+                action: 'killed',
+                sessionName: payload.sessionName,
+            });
         }
         else {
             this.send(client.ws, {
@@ -1044,6 +1337,105 @@ class WebSocketHandler {
             });
         }
     }
+    async handleCreateWorktreeSession(client, payload, requestId) {
+        if (!payload?.parentDir) {
+            this.send(client.ws, {
+                type: 'worktree_session_created',
+                success: false,
+                error: 'Missing parentDir',
+                requestId,
+            });
+            return;
+        }
+        // Validate parent directory is a git repo
+        if (!(await this.tmux.isGitRepo(payload.parentDir))) {
+            this.send(client.ws, {
+                type: 'worktree_session_created',
+                success: false,
+                error: 'Not a git repository',
+                requestId,
+            });
+            return;
+        }
+        console.log(`WebSocket: Creating worktree session from ${payload.parentDir}, branch: ${payload.branch || 'auto'}`);
+        // Create the git worktree
+        const wtResult = await this.tmux.createWorktree(payload.parentDir, payload.branch);
+        if (!wtResult.success || !wtResult.worktreePath) {
+            this.send(client.ws, {
+                type: 'worktree_session_created',
+                success: false,
+                error: wtResult.error || 'Failed to create worktree',
+                requestId,
+            });
+            return;
+        }
+        // Create a tmux session in the worktree directory
+        const sessionName = this.tmux.generateSessionName(wtResult.worktreePath);
+        const startCli = payload.startCli !== false;
+        const tmuxResult = await this.tmux.createSession(sessionName, wtResult.worktreePath, startCli);
+        if (tmuxResult.success) {
+            // Store session config with worktree metadata
+            this.storeTmuxSessionConfig(sessionName, wtResult.worktreePath, startCli);
+            // Also store worktree info in the config
+            const configs = this.tmuxSessionConfigs;
+            const config = configs.get(sessionName);
+            if (config) {
+                config.isWorktree = true;
+                config.mainRepoDir = payload.parentDir;
+                config.branch = wtResult.branch;
+                this.saveTmuxSessionConfigs();
+            }
+            // Switch input target to the new session
+            this.injector.setActiveSession(sessionName);
+            this.watcher.clearActiveSession();
+            await this.watcher.refreshTmuxPaths();
+            this.send(client.ws, {
+                type: 'worktree_session_created',
+                success: true,
+                payload: {
+                    sessionName,
+                    workingDir: wtResult.worktreePath,
+                    branch: wtResult.branch,
+                    mainRepoDir: payload.parentDir,
+                },
+                requestId,
+            });
+            this.broadcast('tmux_sessions_changed', {
+                action: 'created',
+                sessionName,
+                isWorktree: true,
+                branch: wtResult.branch,
+            });
+        }
+        else {
+            // Clean up the worktree since tmux session failed
+            await this.tmux.removeWorktree(payload.parentDir, wtResult.worktreePath);
+            this.send(client.ws, {
+                type: 'worktree_session_created',
+                success: false,
+                error: tmuxResult.error || 'Failed to create tmux session',
+                requestId,
+            });
+        }
+    }
+    async handleListWorktrees(client, payload, requestId) {
+        if (!payload?.dir) {
+            this.send(client.ws, {
+                type: 'worktrees_list',
+                success: false,
+                error: 'Missing dir',
+                requestId,
+            });
+            return;
+        }
+        const worktrees = await this.tmux.listWorktrees(payload.dir);
+        this.send(client.ws, {
+            type: 'worktrees_list',
+            success: true,
+            payload: { worktrees },
+            requestId,
+        });
+    }
     async handleSwitchTmuxSession(client, payload, requestId) {
         if (!payload?.sessionName) {
             this.send(client.ws, {
@@ -1075,7 +1467,7 @@ class WebSocketHandler {
         // Try to find and switch to the corresponding conversation session
         // Get the tmux session's working directory
         const sessions = await this.tmux.listSessions();
-        const tmuxSession = sessions.find(s => s.name === payload.sessionName);
+        const tmuxSession = sessions.find((s) => s.name === payload.sessionName);
         let conversationSessionId;
         if (tmuxSession?.workingDir) {
             // Store the session config for potential recreation later
@@ -1084,7 +1476,7 @@ class WebSocketHandler {
             const encodedPath = tmuxSession.workingDir.replace(/\//g, '-');
             // Find conversation session whose ID matches or starts with this encoded path
             const convSessions = this.watcher.getSessions();
-            const matchingConv = convSessions.find(cs => cs.id === encodedPath);
+            const matchingConv = convSessions.find((cs) => cs.id === encodedPath);
             if (matchingConv) {
                 this.watcher.setActiveSession(matchingConv.id);
                 conversationSessionId = matchingConv.id;
@@ -1093,7 +1485,7 @@ class WebSocketHandler {
             else {
                 // No conversation yet for this project - clear active session so old data stops flowing
                 this.watcher.clearActiveSession();
-                console.log(`WebSocket: No conversation found for ${encodedPath}, cleared active session. Available: ${convSessions.map(c => c.id).join(', ')}`);
+                console.log(`WebSocket: No conversation found for ${encodedPath}, cleared active session. Available: ${convSessions.map((c) => c.id).join(', ')}`);
             }
         }
         else {
@@ -1265,7 +1657,7 @@ class WebSocketHandler {
                 if (activeSessionId) {
                     // The session ID is the encoded path like -Users-foo-project
                     // Match it against tmux session working directories
-                    const matchingSession = sessions.find(s => {
+                    const matchingSession = sessions.find((s) => {
                         if (!s.workingDir)
                             return false;
                         const encoded = s.workingDir.replace(/\//g, '-');
@@ -1280,12 +1672,8 @@ class WebSocketHandler {
             // Normalize the path
             resolvedPath = path.normalize(resolvedPath);
             // Security: only allow reading files in certain directories
-            const allowedPaths = [
-                homeDir,
-                '/tmp',
-                '/var/tmp',
-            ];
-            const isAllowed = allowedPaths.some(allowed => resolvedPath.startsWith(allowed));
+            const allowedPaths = [homeDir, '/tmp', '/var/tmp'];
+            const isAllowed = allowedPaths.some((allowed) => resolvedPath.startsWith(allowed));
             if (!isAllowed) {
                 this.send(client.ws, {
                     type: 'file_content',
@@ -1333,6 +1721,94 @@ class WebSocketHandler {
             });
         }
     }
+    async handleOpenInEditor(client, payload, requestId) {
+        const filePath = payload?.path;
+        if (!filePath) {
+            this.send(client.ws, {
+                type: 'open_in_editor',
+                success: false,
+                error: 'No file path provided',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const homeDir = this.tmux.getHomeDir();
+            let resolvedPath;
+            if (filePath.startsWith('~/')) {
+                resolvedPath = path.join(homeDir, filePath.slice(2));
+            }
+            else if (filePath.startsWith('/')) {
+                resolvedPath = filePath;
+            }
+            else {
+                resolvedPath = path.resolve(homeDir, filePath);
+            }
+            resolvedPath = path.normalize(resolvedPath);
+            // Security: only allow opening files in home directory or /tmp
+            const allowedPaths = [homeDir, '/tmp', '/var/tmp'];
+            const isAllowed = allowedPaths.some((allowed) => resolvedPath.startsWith(allowed));
+            if (!isAllowed) {
+                this.send(client.ws, {
+                    type: 'open_in_editor',
+                    success: false,
+                    error: `Access denied: file outside allowed directories`,
+                    requestId,
+                });
+                return;
+            }
+            // Check file exists
+            if (!fs.existsSync(resolvedPath)) {
+                this.send(client.ws, {
+                    type: 'open_in_editor',
+                    success: false,
+                    error: 'File not found',
+                    requestId,
+                });
+                return;
+            }
+            // Determine the editor command
+            // Priority: $VISUAL > $EDITOR > platform default (open/xdg-open)
+            const editor = process.env.VISUAL || process.env.EDITOR;
+            let cmd;
+            let args;
+            if (editor) {
+                // Split editor string in case it has flags (e.g. "code --wait")
+                const parts = editor.split(/\s+/);
+                cmd = parts[0];
+                args = [...parts.slice(1), resolvedPath];
+            }
+            else if (process.platform === 'darwin') {
+                cmd = 'open';
+                args = [resolvedPath];
+            }
+            else {
+                cmd = 'xdg-open';
+                args = [resolvedPath];
+            }
+            // Spawn detached so it doesn't block the daemon
+            const child = (0, child_process_1.spawn)(cmd, args, {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            console.log(`Open in editor: ${cmd} ${args.join(' ')}`);
+            this.send(client.ws, {
+                type: 'open_in_editor',
+                success: true,
+                payload: { path: resolvedPath, editor: cmd },
+                requestId,
+            });
+        }
+        catch (err) {
+            this.send(client.ws, {
+                type: 'open_in_editor',
+                success: false,
+                error: `Failed to open file: ${err instanceof Error ? err.message : 'Unknown error'}`,
+                requestId,
+            });
+        }
+    }
     async handleDownloadFile(client, payload, requestId) {
         const filePath = payload?.path;
         if (!filePath) {
@@ -1361,7 +1837,7 @@ class WebSocketHandler {
             resolvedPath = path.normalize(resolvedPath);
             // Security: only allow downloading files in certain directories
             const allowedPaths = [homeDir, '/tmp', '/var/tmp'];
-            const isAllowed = allowedPaths.some(allowed => resolvedPath.startsWith(allowed));
+            const isAllowed = allowedPaths.some((allowed) => resolvedPath.startsWith(allowed));
             if (!isAllowed) {
                 this.send(client.ws, {
                     type: 'file_download',
@@ -1374,7 +1850,7 @@ class WebSocketHandler {
             // Only allow specific file types for download
             const allowedExtensions = ['.apk', '.ipa', '.zip', '.tar.gz', '.tgz'];
             const ext = path.extname(resolvedPath).toLowerCase();
-            const isApkOrZip = allowedExtensions.some(e => resolvedPath.toLowerCase().endsWith(e));
+            const isApkOrZip = allowedExtensions.some((e) => resolvedPath.toLowerCase().endsWith(e));
             if (!isApkOrZip) {
                 this.send(client.ws, {
                     type: 'file_download',
@@ -1666,6 +2142,171 @@ class WebSocketHandler {
             error,
         });
     }
+    // --- Work Group handlers ---
+    async handleSpawnWorkGroup(client, payload, requestId) {
+        if (!this.workGroupManager) {
+            this.send(client.ws, {
+                type: 'work_group_spawned',
+                success: false,
+                error: 'Work groups not enabled',
+                requestId,
+            });
+            return;
+        }
+        if (!payload?.name || !payload.workers?.length) {
+            this.send(client.ws, {
+                type: 'work_group_spawned',
+                success: false,
+                error: 'Missing name or workers',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const group = await this.workGroupManager.createWorkGroup({
+                name: payload.name,
+                foremanSessionId: payload.foremanSessionId,
+                foremanTmuxSession: payload.foremanTmuxSession,
+                parentDir: payload.parentDir,
+                planFile: payload.planFile,
+                workers: payload.workers,
+            });
+            this.send(client.ws, {
+                type: 'work_group_spawned',
+                success: true,
+                payload: group,
+                requestId,
+            });
+        }
+        catch (err) {
+            this.send(client.ws, {
+                type: 'work_group_spawned',
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+                requestId,
+            });
+        }
+    }
+    handleGetWorkGroups(client, requestId) {
+        if (!this.workGroupManager) {
+            this.send(client.ws, {
+                type: 'work_groups',
+                success: true,
+                payload: { groups: [] },
+                requestId,
+            });
+            return;
+        }
+        const groups = this.workGroupManager.getWorkGroups();
+        this.send(client.ws, { type: 'work_groups', success: true, payload: { groups }, requestId });
+    }
+    handleGetWorkGroup(client, payload, requestId) {
+        if (!this.workGroupManager || !payload?.groupId) {
+            this.send(client.ws, {
+                type: 'work_group',
+                success: false,
+                error: 'Missing groupId',
+                requestId,
+            });
+            return;
+        }
+        const group = this.workGroupManager.getWorkGroup(payload.groupId);
+        if (!group) {
+            this.send(client.ws, { type: 'work_group', success: false, error: 'Not found', requestId });
+            return;
+        }
+        this.send(client.ws, { type: 'work_group', success: true, payload: group, requestId });
+    }
+    async handleMergeWorkGroup(client, payload, requestId) {
+        if (!this.workGroupManager || !payload?.groupId) {
+            this.send(client.ws, {
+                type: 'work_group_merged',
+                success: false,
+                error: 'Missing groupId',
+                requestId,
+            });
+            return;
+        }
+        const result = await this.workGroupManager.mergeWorkGroup(payload.groupId);
+        this.send(client.ws, {
+            type: 'work_group_merged',
+            success: result.success,
+            payload: result,
+            requestId,
+        });
+    }
+    async handleCancelWorkGroup(client, payload, requestId) {
+        if (!this.workGroupManager || !payload?.groupId) {
+            this.send(client.ws, {
+                type: 'work_group_cancelled',
+                success: false,
+                error: 'Missing groupId',
+                requestId,
+            });
+            return;
+        }
+        const result = await this.workGroupManager.cancelWorkGroup(payload.groupId);
+        this.send(client.ws, {
+            type: 'work_group_cancelled',
+            success: result.success,
+            error: result.error,
+            requestId,
+        });
+    }
+    async handleRetryWorker(client, payload, requestId) {
+        if (!this.workGroupManager || !payload?.groupId || !payload?.workerId) {
+            this.send(client.ws, {
+                type: 'worker_retried',
+                success: false,
+                error: 'Missing groupId or workerId',
+                requestId,
+            });
+            return;
+        }
+        const result = await this.workGroupManager.retryWorker(payload.groupId, payload.workerId);
+        this.send(client.ws, {
+            type: 'worker_retried',
+            success: result.success,
+            error: result.error,
+            requestId,
+        });
+    }
+    async handleSendWorkerInput(client, payload, requestId) {
+        if (!this.workGroupManager || !payload?.groupId || !payload?.workerId || !payload?.text) {
+            this.send(client.ws, {
+                type: 'worker_input_sent',
+                success: false,
+                error: 'Missing groupId, workerId, or text',
+                requestId,
+            });
+            return;
+        }
+        const result = await this.workGroupManager.sendWorkerInput(payload.groupId, payload.workerId, payload.text);
+        this.send(client.ws, {
+            type: 'worker_input_sent',
+            success: result.success,
+            error: result.error,
+            requestId,
+        });
+    }
+    async handleDismissWorkGroup(client, payload, requestId) {
+        if (!this.workGroupManager || !payload?.groupId) {
+            this.send(client.ws, {
+                type: 'work_group_dismissed',
+                success: false,
+                error: 'Missing groupId',
+                requestId,
+            });
+            return;
+        }
+        const result = await this.workGroupManager.dismissWorkGroup(payload.groupId);
+        this.send(client.ws, {
+            type: 'work_group_dismissed',
+            success: result.success,
+            error: result.success ? undefined : 'Group is not in completed or cancelled state',
+            requestId,
+        });
+    }
     broadcast(type, payload, sessionId) {
         // Get the session ID to include in the message
         const activeSessionId = sessionId || this.watcher.getActiveSessionId();