agentgui 1.0.672 → 1.0.674

package/lib/tool-manager.js

@@ -546,3 +546,74 @@ export async function autoProvision(broadcast) {
   }
   log('Provisioning complete');
 }
+
+// Periodic tool update checker - runs in background every 6 hours
+let updateCheckInterval = null;
+const UPDATE_CHECK_INTERVAL = 6 * 60 * 60 * 1000; // 6 hours
+
+export function startPeriodicUpdateCheck(broadcast) {
+  const log = (msg) => console.log('[TOOLS-PERIODIC] ' + msg);
+
+  if (updateCheckInterval) {
+    log('Update check already running');
+    return;
+  }
+
+  log('Starting periodic tool update checker (every 6 hours)');
+
+  // Run check immediately on startup (non-blocking)
+  setImmediate(() => {
+    checkAndUpdateTools(broadcast).catch(err => {
+      log(`Initial check failed: ${err.message}`);
+    });
+  });
+
+  // Then run periodically every 6 hours
+  updateCheckInterval = setInterval(() => {
+    checkAndUpdateTools(broadcast).catch(err => {
+      log(`Periodic check failed: ${err.message}`);
+    });
+  }, UPDATE_CHECK_INTERVAL);
+}
+
+export function stopPeriodicUpdateCheck() {
+  if (updateCheckInterval) {
+    clearInterval(updateCheckInterval);
+    updateCheckInterval = null;
+    console.log('[TOOLS-PERIODIC] Update check stopped');
+  }
+}
+
+async function checkAndUpdateTools(broadcast) {
+  const log = (msg) => console.log('[TOOLS-PERIODIC] ' + msg);
+  log('Checking for tool updates...');
+
+  for (const tool of TOOLS) {
+    try {
+      const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, false);
+
+      if (status.upgradeNeeded) {
+        log(`Update available for ${tool.id}: ${status.installedVersion} -> ${status.publishedVersion}`);
+        broadcast({ type: 'tool_update_available', toolId: tool.id, data: { installedVersion: status.installedVersion, publishedVersion: status.publishedVersion } });
+
+        // Auto-update in background (non-blocking)
+        log(`Auto-updating ${tool.id}...`);
+        const result = await update(tool.id, (msg) => {
+          broadcast({ type: 'tool_update_progress', toolId: tool.id, data: msg });
+        });
+
+        if (result.success) {
+          log(`${tool.id} auto-updated to v${result.version}`);
+          broadcast({ type: 'tool_update_complete', toolId: tool.id, data: { ...result, autoUpdated: true } });
+        } else {
+          log(`${tool.id} auto-update failed: ${result.error}`);
+          broadcast({ type: 'tool_update_failed', toolId: tool.id, data: { ...result, autoUpdated: true } });
+        }
+      }
+    } catch (err) {
+      log(`Error checking ${tool.id}: ${err.message}`);
+    }
+  }
+
+  log('Update check complete');
+}

package/lib/ws-handlers-conv.js

@@ -7,7 +7,7 @@ function expandTilde(p) { return p && p.startsWith('~') ? path.join(os.homedir()
 
 export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts } = deps;
+    broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts, cleanupExecution } = deps;
 
   router.handle('conv.ls', () => {
     const conversations = queries.getConversationsList();
@@ -95,8 +95,10 @@ export function register(router, deps) {
     const { pid, sessionId } = entry;
     if (pid) { try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch {} } }
     if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
-    queries.setIsStreaming(p.id, false);
-    activeExecutions.delete(p.id);
+
+    // Use atomic cleanup function to ensure state consistency
+    cleanupExecution(p.id, false);
+
     broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
     return { ok: true, cancelled: true, conversationId: p.id, sessionId };
   });

package/lib/ws-handlers-run.js

@@ -152,6 +152,32 @@ function register(router, deps) {
     if (!run || run.thread_id !== threadId) err(404, 'Run not found on thread');
     return run;
   });
+
+  router.handle('thread.run.steer', async (p) => {
+    const threadId = need(p, 'id'), runId = need(p, 'runId'), instruction = need(p, 'instruction');
+    const thread = getThreadOrThrow(threadId);
+    const run = getRunOrThrow(runId);
+    if (run.thread_id !== threadId) err(400, 'Run does not belong to specified thread');
+    if (!['active', 'pending'].includes(run.status)) err(409, 'Run is not active or pending');
+
+    // Cancel current run
+    const cancelled = queries.cancelRun(runId);
+    const ex = killExecution(threadId, runId);
+    broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: ex?.sessionId, timestamp: Date.now() });
+
+    // Create new run with steering instruction injected
+    // The instruction will be processed as a follow-up in the same thread context
+    const newRun = queries.createRun(run.agent_id, threadId, { content: instruction }, run.config);
+    startExecution(newRun.run_id, threadId, run.agent_id, { content: instruction }, run.config);
+
+    return {
+      steered: true,
+      cancelled_run: cancelled,
+      new_run: newRun,
+      instruction: instruction,
+      message: 'Run interrupted and restarted with steering instruction'
+    };
+  });
 }
 
 export { register };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.672",
+  "version": "1.0.674",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -311,6 +311,45 @@ const debugLog = (msg) => {
   console.error(`[${timestamp}] ${msg}`);
 };
 
+// Atomic cleanup function - ensures consistent state across all data structures
+function cleanupExecution(conversationId, broadcastCompletion = false) {
+  debugLog(`[cleanup] Starting cleanup for ${conversationId}`);
+
+  // Clean in-memory maps in atomic block
+  activeExecutions.delete(conversationId);
+  const proc = activeProcessesByConvId.get(conversationId);
+  activeProcessesByConvId.delete(conversationId);
+
+  // Cancel steering timeout if present
+  const steeringTimeout = steeringTimeouts.get(conversationId);
+  if (steeringTimeout) {
+    clearTimeout(steeringTimeout);
+    steeringTimeouts.delete(conversationId);
+  }
+
+  // Try to kill process if still alive
+  if (proc) {
+    try {
+      if (proc.kill) proc.kill('SIGTERM');
+    } catch (e) {
+      debugLog(`[cleanup] Error killing process: ${e.message}`);
+    }
+  }
+
+  // Clean database state
+  queries.setIsStreaming(conversationId, false);
+
+  if (broadcastCompletion) {
+    broadcastSync({
+      type: 'execution_cleaned_up',
+      conversationId,
+      timestamp: Date.now()
+    });
+  }
+
+  debugLog(`[cleanup] Cleanup complete for ${conversationId}`);
+}
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = process.env.PORTABLE_EXE_DIR || __dirname;
 const PORT = process.env.PORT || 3000;
@@ -3237,7 +3276,7 @@ function serveFile(filePath, res, req) {
         'Content-Type': contentType,
         'Content-Length': stats.size,
         'ETag': etag,
-        'Cache-Control': ['.js', '.css'].includes(ext) ? 'no-cache' : 'public, max-age=3600, must-revalidate'
+        'Cache-Control': ['.js', '.css'].includes(ext) ? 'public, max-age=0, must-revalidate' : 'public, max-age=3600, must-revalidate'
       };
       if (acceptsEncoding(req, 'br') && stats.size > 860) {
         const stream = fs.createReadStream(filePath);
@@ -3832,10 +3871,18 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     });
   } finally {
     batcher.drain();
-    activeExecutions.delete(conversationId);
+    // Use atomic cleanup but only if not in rate limit recovery
     if (!rateLimitState.has(conversationId)) {
-      queries.setIsStreaming(conversationId, false);
+      cleanupExecution(conversationId);
       drainMessageQueue(conversationId);
+    } else {
+      // Rate limit in flight - keep execution entry for now, but clean process handle
+      activeProcessesByConvId.delete(conversationId);
+      const steeringTimeout = steeringTimeouts.get(conversationId);
+      if (steeringTimeout) {
+        clearTimeout(steeringTimeout);
+        steeringTimeouts.delete(conversationId);
+      }
     }
   }
 }
@@ -3871,6 +3918,16 @@ function scheduleRetry(conversationId, messageId, content, agentId, model, subAg
     .catch(err => {
       debugLog(`[rate-limit] Retry failed: ${err.message}`);
       console.error(`[rate-limit] Retry error for conv ${conversationId}:`, err);
+      // Clean up state on retry failure
+      cleanupExecution(conversationId);
+      broadcastSync({
+        type: 'streaming_error',
+        sessionId: newSession.id,
+        conversationId,
+        error: `Rate limit retry failed: ${err.message}`,
+        recoverable: false,
+        timestamp: Date.now()
+      });
     });
 }
 
@@ -3915,7 +3972,21 @@ function drainMessageQueue(conversationId) {
   activeExecutions.set(conversationId, { pid: null, startTime, sessionId: session.id, lastActivity: startTime });
 
   processMessageWithStreaming(conversationId, next.messageId, session.id, next.content, next.agentId, next.model, next.subAgent)
-    .catch(err => debugLog(`[queue] Error processing queued message: ${err.message}`));
+    .catch(err => {
+      debugLog(`[queue] Error processing queued message: ${err.message}`);
+      // CRITICAL: Clean up state on error so next message can be retried
+      cleanupExecution(conversationId);
+      broadcastSync({
+        type: 'streaming_error',
+        sessionId: session.id,
+        conversationId,
+        error: `Queue processing failed: ${err.message}`,
+        recoverable: true,
+        timestamp: Date.now()
+      });
+      // Try to drain next message in queue
+      setTimeout(() => drainMessageQueue(conversationId), 100);
+    });
 }
 
 
@@ -4026,7 +4097,8 @@ const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts
+  broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts,
+  cleanupExecution
 });
 
 console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);
@@ -4151,7 +4223,8 @@ wsRouter.onLegacy((data, ws) => {
       try { ws.terminalProc.kill(); } catch(e) {}
     }
     try {
-      const pty = require('node-pty');
+      const _req = createRequire(import.meta.url);
+      const pty = _req('node-pty');
       const shell = process.env.SHELL || '/bin/bash';
       const cwd = data.cwd || process.env.STARTUP_CWD || process.env.HOME || '/';
       const proc = pty.spawn(shell, [], {
@@ -4178,7 +4251,6 @@ wsRouter.onLegacy((data, ws) => {
       sendWs(ws, ({ type: 'terminal_started', timestamp: Date.now() }));
     } catch (e) {
       console.error('[TERMINAL] Failed to spawn PTY, falling back to pipes:', e.message);
-      const { spawn } = require('child_process');
       const shell = process.env.SHELL || '/bin/bash';
       const cwd = data.cwd || process.env.STARTUP_CWD || process.env.HOME || '/';
       const proc = spawn(shell, ['-i'], { cwd, env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor' }, stdio: ['pipe', 'pipe', 'pipe'] });
@@ -4540,10 +4612,12 @@ function onServerReady() {
     }, 6000);
   }).catch(err => console.error('[ACP] Startup error:', err.message));
 
-  const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
+  const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
   queries.initializeToolInstallations(toolIds.map(id => ({ id })));
   console.log('[TOOLS] Starting background provisioning...');
-  toolManager.autoProvision((evt) => {
+
+  // Create broadcast handler for tool events
+  const toolBroadcaster = (evt) => {
     broadcastSync(evt);
     if (evt.type === 'tool_install_complete' || evt.type === 'tool_update_complete') {
       const d = evt.data || {};
@@ -4558,7 +4632,17 @@ function onServerReady() {
         queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.installedVersion || null, installed_at: Date.now() });
       }
     }
-  }).catch(err => console.error('[TOOLS] Auto-provision error:', err.message));
+  };
+
+  // Initial provisioning (blocks until complete)
+  toolManager.autoProvision(toolBroadcaster)
+    .catch(err => console.error('[TOOLS] Auto-provision error:', err.message))
+    .then(() => {
+      // Start periodic update checker AFTER initial provisioning completes
+      // This runs in background and doesn't block GUI
+      console.log('[TOOLS] Starting periodic update checker...');
+      toolManager.startPeriodicUpdateCheck(toolBroadcaster);
+    });
 
   ensureModelsDownloaded().then(async ok => {
     if (ok) console.log('[MODELS] Speech models ready');

package/static/js/client.js

@@ -157,6 +157,9 @@ class AgentGUIClient {
       this._recoverMissedChunks();
       this.updateSendButtonState();
       this.enablePromptArea();
+      if (this.state.currentConversation?.id) {
+        this.updateBusyPromptArea(this.state.currentConversation.id);
+      }
       this.emit('ws:connected');
       // Check if server was updated while client was loaded - reload if version changed
       if (window.__SERVER_VERSION) {
@@ -2045,8 +2048,6 @@ class AgentGUIClient {
         </div>
       </div>
     `;
-    // Keep loading spinner visible during hydration
-    this.showLoadingSpinner();
   }
 
   async streamToConversation(conversationId, prompt, agentId, model, subAgent) {
@@ -2084,6 +2085,7 @@ class AgentGUIClient {
 
       if (result.queued) {
         console.log('Message queued, position:', result.queuePosition);
+        this.enableControls();
         return;
       }
 
@@ -2491,22 +2493,20 @@ class AgentGUIClient {
   }
 
   /**
-   * Disable UI controls during streaming
-   * NOTE: Prompt area is IMMUTABLE - always enabled while connected.
-   * Streaming state is rendered via queue/steer buttons, not input disabling.
+   * Disable UI controls during execution - prevents double-sends
    */
   disableControls() {
-    // IMMUTABLE: Prompt state managed only by syncPromptState() based on WebSocket connection
-    // Never disable input during streaming - use queue/steer visibility instead
+    if (this.ui.sendButton) this.ui.sendButton.disabled = true;
   }
 
   /**
-   * Enable UI controls
-   * NOTE: Prompt area is always enabled when connected.
+   * Enable UI controls after execution completes or fails
    */
   enableControls() {
-    // IMMUTABLE: Prompt state managed only by syncPromptState() based on WebSocket connection
-    // Never disable input during streaming - use queue/steer visibility instead
+    if (this.ui.sendButton) {
+      this.ui.sendButton.disabled = !this.wsManager?.isConnected;
+    }
+    this.updateBusyPromptArea(this.state.currentConversation?.id);
   }
 
   /**
@@ -2686,10 +2686,6 @@ class AgentGUIClient {
           this.conversationCache.delete(conversationId);
           this.syncPromptState(conversationId);
           this.restoreScrollPosition(conversationId);
-          // Hydration complete - hide loading spinner
-          this.hideLoadingSpinner();
-          // Prompt state is immutable: computed from shouldResumeStreaming via syncPromptState
-          // Do not call enableControls/disableControls here - prompt state is determined by streaming status
           return;
         }
       }
@@ -2700,9 +2696,8 @@ class AgentGUIClient {
 
       let fullData;
       try {
-        // Load only recent chunks initially (lazy load older ones)
-        // Use chunkLimit of 50 to make page load faster
         fullData = await window.wsClient.rpc('conv.full', { id: conversationId, chunkLimit: 50 });
+        if (convSignal.aborted) return;
       } catch (e) {
         if (e.code === 404) {
           console.warn('Conversation no longer exists:', conversationId);
@@ -2724,6 +2719,7 @@ class AgentGUIClient {
         }
         throw e;
       }
+      if (convSignal.aborted) return;
       const { conversation, isActivelyStreaming, latestSession, chunks: rawChunks, totalChunks, messages: allMessages } = fullData;
 
       window.ConversationState?.selectConversation(conversationId, 'server_load', 1);
@@ -2736,18 +2732,32 @@ class AgentGUIClient {
         ...chunk,
         block: typeof chunk.data === 'string' ? JSON.parse(chunk.data) : chunk.data
       }));
-      const userMessages = (allMessages || []).filter(m => m.role === 'user');
+
+      // Fetch queue to exclude queued messages from being rendered as regular user messages
+      let queuedMessageIds = new Set();
+      try {
+        const { queue } = await window.wsClient.rpc('q.ls', { id: conversationId });
+        if (queue && queue.length > 0) {
+          queuedMessageIds = new Set(queue.map(q => q.messageId));
+        }
+      } catch (e) {
+        console.warn('Failed to fetch queue:', e.message);
+      }
+
+      // Filter out queued messages from user messages - they'll be rendered in queue indicator instead
+      const userMessages = (allMessages || []).filter(m => m.role === 'user' && !queuedMessageIds.has(m.id));
       const hasMoreChunks = totalChunks && chunks.length < totalChunks;
 
       const clientKnowsStreaming = this.state.streamingConversations.has(conversationId);
       const shouldResumeStreaming = latestSession &&
         (latestSession.status === 'active' || latestSession.status === 'pending');
 
-      // IMMUTABLE: Update streaming state and disable prompt atomically
       if (shouldResumeStreaming) {
         this.state.streamingConversations.set(conversationId, true);
+        window.dispatchEvent(new CustomEvent('ws-message', { detail: { type: 'streaming_start', conversationId, sessionId: latestSession?.id } }));
       } else {
         this.state.streamingConversations.delete(conversationId);
+        window.dispatchEvent(new CustomEvent('ws-message', { detail: { type: 'streaming_complete', conversationId } }));
       }
 
       if (this.ui.messageInput) {
@@ -2948,12 +2958,13 @@ class AgentGUIClient {
 
         this.restoreScrollPosition(conversationId);
         this.setupScrollUpDetection(conversationId);
-        // Hydration complete - hide loading spinner
-        this.hideLoadingSpinner();
+
+        // Fetch and display queue items so queued messages show in yellow blocks, not as user messages
+        this.fetchAndRenderQueue(conversationId);
+
       }
     } catch (error) {
       if (error.name === 'AbortError') return;
-      this.hideLoadingSpinner();
       console.error('Failed to load conversation messages:', error);
       // Resume from last successful conversation if available, or fall back to any available conversation
       const fallbackConv = prevConversationId ? prevConversationId : availableFallback?.id;
@@ -3198,7 +3209,7 @@ class AgentGUIClient {
   }
 
   saveAgentAndModelToConversation() {
-    const convId = this.state.currentConversation;
+    const convId = this.state.currentConversation?.id;
     if (!convId || this._agentLocked) return;
     const agentId = this.getEffectiveAgentId();
     const subAgent = this.getEffectiveSubAgent();
@@ -3338,6 +3349,7 @@ let agentGUIClient = null;
 document.addEventListener('DOMContentLoaded', async () => {
   try {
     agentGUIClient = new AgentGUIClient();
+    window.agentGuiClient = agentGUIClient;
     await agentGUIClient.init();
     console.log('AgentGUI ready');
   } catch (error) {

package/static/js/conversations.js

@@ -433,8 +433,11 @@ class ConversationManager {
 
       this._updateConversations(convList, 'poll');
 
+      const clientStreamingMap = window.agentGuiClient?.state?.streamingConversations;
       for (const conv of this.conversations) {
-        if (conv.isStreaming === 1 || conv.isStreaming === true) {
+        const serverStreaming = conv.isStreaming === 1 || conv.isStreaming === true;
+        const clientStreaming = clientStreamingMap ? clientStreamingMap.has(conv.id) : false;
+        if (serverStreaming || clientStreaming) {
           this.streamingConversations.add(conv.id);
         } else {
           this.streamingConversations.delete(conv.id);

package/static/js/features.js

@@ -39,6 +39,7 @@
     }
     function closeSidebar() {
       sidebar.classList.remove('mobile-visible');
+      sidebar.classList.add('collapsed'); // Ensure sidebar is hidden on close
       if (overlay) overlay.classList.remove('visible');
     }
     if (toggleBtn) toggleBtn.addEventListener('click', function(e) { e.stopPropagation(); toggleSidebar(); });

package/static/js/terminal.js

@@ -1,39 +1,31 @@
 (function() {
-  var ws = null;
   var term = null;
   var fitAddon = null;
   var termActive = false;
   var BASE = window.__BASE_URL || '';
-
-  function getWsUrl() {
-    var proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
-    return proto + '//' + location.host + BASE + '/sync';
-  }
+  var _wsListener = null;
 
   function getCwd() {
     try {
-      // Try conversation manager first
       if (window.conversationManager && window.conversationManager.activeId) {
         var mgr = window.conversationManager;
-        var id = mgr.activeId;
-        if (mgr.conversations) {
-          var conv = mgr.conversations.find(function(c) { return c.id === id; });
-          if (conv && conv.workingDirectory) return conv.workingDirectory;
-        }
+        var conv = mgr.conversations && mgr.conversations.find(function(c) { return c.id === mgr.activeId; });
+        if (conv && conv.workingDirectory) return conv.workingDirectory;
       }
-      // Fallback to global currentConversation
-      if (window.currentConversation) {
-        var convId = window.currentConversation;
-        if (window.conversationManager && window.conversationManager.conversations) {
-          var convList = window.conversationManager.conversations;
-          var match = convList.find(function(c) { return c.id === convId; });
-          if (match && match.workingDirectory) return match.workingDirectory;
-        }
+      if (window.currentConversation && window.conversationManager && window.conversationManager.conversations) {
+        var match = window.conversationManager.conversations.find(function(c) { return c.id === window.currentConversation; });
+        if (match && match.workingDirectory) return match.workingDirectory;
       }
     } catch (_) {}
     return undefined;
   }
 
+  function wsSend(obj) {
+    if (window.wsManager && window.wsManager.send) {
+      window.wsManager.send(obj);
+    }
+  }
+
   function ensureTerm() {
     var output = document.getElementById('terminalOutput');
     if (!output) return false;
@@ -60,16 +52,12 @@
     fitAddon.fit();
 
     term.onData(function(data) {
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        var encoded = btoa(unescape(encodeURIComponent(data)));
-        ws.send(JSON.stringify({ type: 'terminal_input', data: encoded }));
-      }
+      var encoded = btoa(unescape(encodeURIComponent(data)));
+      wsSend({ type: 'terminal_input', data: encoded });
     });
 
     term.onResize(function(size) {
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: 'terminal_resize', cols: size.cols, rows: size.rows }));
-      }
+      wsSend({ type: 'terminal_resize', cols: size.cols, rows: size.rows });
     });
 
     var resizeTimer;
@@ -78,57 +66,42 @@
         try { fitAddon.fit(); } catch(_) {}
         clearTimeout(resizeTimer);
         resizeTimer = setTimeout(function() {
-          if (term && ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({ type: 'terminal_resize', cols: term.cols, rows: term.rows }));
-          }
+          if (term) wsSend({ type: 'terminal_resize', cols: term.cols, rows: term.rows });
         }, 200);
       }
     });
 
-    output.addEventListener('click', function() {
+    document.getElementById('terminalOutput').addEventListener('click', function() {
       if (term && term.focus) term.focus();
     });
 
     return true;
   }
 
-  function connectAndStart() {
-    var cwd = getCwd();
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      var dims = term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
-      ws.send(JSON.stringify({ type: 'terminal_start', cwd: cwd, cols: dims.cols, rows: dims.rows }));
-      setTimeout(function() { if (term && term.focus) term.focus(); }, 100);
-      return;
-    }
-    if (ws && ws.readyState === WebSocket.CONNECTING) {
-      return;
-    }
-
-    ws = new WebSocket(getWsUrl());
-    ws.onopen = function() {
-      var dims = term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
-      ws.send(JSON.stringify({ type: 'terminal_start', cwd: cwd, cols: dims.cols, rows: dims.rows }));
-      setTimeout(function() { if (term && term.focus) term.focus(); }, 100);
-    };
-    ws.onmessage = function(e) {
-      try {
-        var msg = JSON.parse(e.data);
-        if (msg.type === 'terminal_output' && term) {
-          var raw = msg.encoding === 'base64'
-            ? decodeURIComponent(escape(atob(msg.data)))
-            : msg.data;
-          term.write(raw);
-        } else if (msg.type === 'terminal_exit' && term) {
-          term.write('\r\n[Process exited with code ' + msg.code + ']\r\n');
-          if (termActive) setTimeout(connectAndStart, 2000);
-        }
-      } catch(_) {}
-    };
-    ws.onclose = function() {
-      ws = null;
-      if (termActive) setTimeout(connectAndStart, 2000);
+  function installWsListener() {
+    if (_wsListener || !window.wsManager) return;
+    _wsListener = function(msg) {
+      if (!termActive) return;
+      if (msg.type === 'terminal_output' && term) {
+        var raw = msg.encoding === 'base64'
+          ? decodeURIComponent(escape(atob(msg.data)))
+          : msg.data;
+        term.write(raw);
+      } else if (msg.type === 'terminal_exit' && term) {
+        term.write('\r\n[Process exited with code ' + msg.code + ']\r\n');
+        if (termActive) setTimeout(startSession, 2000);
+      }
     };
-    ws.onerror = function() {};
+    window.wsManager.on('message', _wsListener);
+  }
+
+  function startSession() {
+    if (!window.wsManager) return;
+    installWsListener();
+    var cwd = getCwd();
+    var dims = term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
+    wsSend({ type: 'terminal_start', cwd: cwd, cols: dims.cols, rows: dims.rows });
+    setTimeout(function() { if (term && term.focus) term.focus(); }, 100);
   }
 
   function startTerminal() {
@@ -137,19 +110,21 @@
       return;
     }
     termActive = true;
-    connectAndStart();
+    if (window.wsManager && window.wsManager.isConnected) {
+      startSession();
+    } else if (window.wsManager) {
+      var onConnected = function() {
+        window.wsManager.off('connected', onConnected);
+        startSession();
+      };
+      window.wsManager.on('connected', onConnected);
+    }
     setTimeout(function() { if (fitAddon) try { fitAddon.fit(); } catch(_) {} }, 100);
   }
 
   function stopTerminal() {
     termActive = false;
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: 'terminal_stop' }));
-    }
-    if (ws) {
-      ws.close();
-      ws = null;
-    }
+    wsSend({ type: 'terminal_stop' });
   }
 
   function initTerminalEarly() {
@@ -172,7 +147,7 @@
         return;
       }
       termActive = true;
-      connectAndStart();
+      startSession();
       setTimeout(function() { if (fitAddon) try { fitAddon.fit(); } catch(_) {} }, 50);
       setTimeout(function() { if (fitAddon) try { fitAddon.fit(); } catch(_) {} }, 300);
     } else if (termActive) {
@@ -180,15 +155,12 @@
     }
   });
 
-  // Restart terminal in the new conversation's cwd when conversation switches while terminal is active
-  window.addEventListener('conversation-changed', function(e) {
+  window.addEventListener('conversation-changed', function() {
     if (!termActive) return;
     var cwd = getCwd();
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      var dims = term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
-      ws.send(JSON.stringify({ type: 'terminal_start', cwd: cwd, cols: dims.cols, rows: dims.rows }));
-      if (term) term.write('\r\n\x1b[33m[Switched to: ' + (cwd || '/') + ']\x1b[0m\r\n');
-    }
+    var dims = term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
+    wsSend({ type: 'terminal_start', cwd: cwd, cols: dims.cols, rows: dims.rows });
+    if (term) term.write('\r\n\x1b[33m[Switched to: ' + (cwd || '/') + ']\x1b[0m\r\n');
   });
 
   window.terminalModule = {