agentgui 1.0.673 → 1.0.675

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,17 @@ 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;
+
+  // Per-conversation queue seq counter for event ordering
+  const queueSeqByConv = new Map();
+
+  function getNextQueueSeq(conversationId) {
+    const current = queueSeqByConv.get(conversationId) || 0;
+    const next = current + 1;
+    queueSeqByConv.set(conversationId, next);
+    return next;
+  }
 
   router.handle('conv.ls', () => {
     const conversations = queries.getConversationsList();
@@ -95,8 +105,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 };
   });
@@ -245,6 +257,14 @@ export function register(router, deps) {
 
     // Message is queued - don't broadcast as message_created, let queue_status handle the UI update
     const qp = enqueue(p.id, prompt, agentId, model, userMessage.id, subAgent);
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({
+      type: 'queue_status',
+      conversationId: p.id,
+      queueLength: messageQueues.get(p.id)?.length || 1,
+      seq,
+      timestamp: Date.now()
+    });
     return { message: userMessage, queued: true, queuePosition: qp };
   });
 
@@ -260,7 +280,14 @@ export function register(router, deps) {
     if (idx === -1) notFound('Queued message not found');
     queue.splice(idx, 1);
     if (queue.length === 0) messageQueues.delete(p.id);
-    broadcastSync({ type: 'queue_status', conversationId: p.id, queueLength: queue?.length || 0, timestamp: Date.now() });
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({
+      type: 'queue_status',
+      conversationId: p.id,
+      queueLength: queue?.length || 0,
+      seq,
+      timestamp: Date.now()
+    });
     return { deleted: true };
   });
 
@@ -271,7 +298,16 @@ export function register(router, deps) {
     if (!item) notFound('Queued message not found');
     if (p.content !== undefined) item.content = p.content;
     if (p.agentId !== undefined) item.agentId = p.agentId;
-    broadcastSync({ type: 'queue_updated', conversationId: p.id, messageId: p.messageId, content: item.content, agentId: item.agentId, timestamp: Date.now() });
+    const seq = getNextQueueSeq(p.id);
+    broadcastSync({
+      type: 'queue_updated',
+      conversationId: p.id,
+      messageId: p.messageId,
+      content: item.content,
+      agentId: item.agentId,
+      seq,
+      timestamp: Date.now()
+    });
     return { updated: true, item };
   });
 }

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.673",
+  "version": "1.0.675",
   "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;
@@ -3317,6 +3356,9 @@ function createChunkBatcher() {
   return { add, drain };
 }
 
+// Global broadcast sequence counter for event ordering
+let broadcastSeq = 0;
+
 function parseRateLimitResetTime(text) {
   const match = text.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
   if (!match) return 300;
@@ -3832,10 +3874,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 +3921,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 +3975,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 +4100,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);
@@ -4540,10 +4615,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 +4635,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/streaming-renderer.js

@@ -136,23 +136,35 @@ class StreamingRenderer {
 
   /**
    * Check if event is a duplicate
+   * For streaming_progress events, use seq+sessionId for precise dedup
+   * For other events, use type+id or type+sessionId
    */
   isDuplicate(event) {
     const key = this.getEventKey(event);
     if (!key) return false;
 
-    const lastTime = this.dedupMap.get(key);
-    const now = Date.now();
+    const lastSeq = this.dedupMap.get(key);
 
-    if (lastTime && (now - lastTime) < 100) {
-      return true;
+    // For streaming_progress with seq, compare seq numbers directly
+    if (event.type === 'streaming_progress' && event.seq !== undefined && lastSeq !== undefined) {
+      if (event.seq <= lastSeq) {
+        return true; // Same or older seq = duplicate
+      }
+      this.dedupMap.set(key, event.seq);
+      return false;
+    }
+
+    // For other events, use time-based dedup
+    const now = Date.now();
+    if (lastSeq && typeof lastSeq === 'number' && lastSeq > now - 500) {
+      return true; // Recent duplicate
     }
 
     this.dedupMap.set(key, now);
     if (this.dedupMap.size > 5000) {
-      const cutoff = now - 1000;
-      for (const [k, t] of this.dedupMap) {
-        if (t < cutoff) this.dedupMap.delete(k);
+      const cutoff = now - 5000;
+      for (const [k, v] of this.dedupMap) {
+        if (typeof v === 'number' && v < cutoff) this.dedupMap.delete(k);
       }
     }
     return false;
@@ -160,10 +172,15 @@ class StreamingRenderer {
 
   /**
    * Generate deduplication key for event
+   * Use sessionId:seq for streaming_progress, fallback to type:id
    */
   getEventKey(event) {
     if (!event.type) return null;
-    return `${event.type}:${event.id || event.sessionId || ''}`;
+    // For streaming events, use sessionId as primary key
+    if (event.sessionId) {
+      return `${event.sessionId}:${event.type}`;
+    }
+    return `${event.type}:${event.id || ''}`;
   }
 
   /**

package/static/js/websocket-manager.js

@@ -480,8 +480,14 @@ class WebSocketManager {
   }
 
   resubscribeAll() {
+    // After reconnect, query server state for all conversations with active subscriptions
+    // This ensures client streaming state matches server state
+    const conversationIds = new Set();
     for (const key of this.activeSubscriptions) {
       const [type, id] = key.split(':');
+      if (type === 'conversation') {
+        conversationIds.add(id);
+      }
       const msg = { type: 'subscribe', timestamp: Date.now() };
       if (type === 'session') msg.sessionId = id;
       else msg.conversationId = id;
@@ -490,6 +496,21 @@ class WebSocketManager {
         this.stats.totalMessagesSent++;
       } catch (_) {}
     }
+
+    // After resubscribing, query streaming state for each conversation
+    // This prevents stale UI state after network hiccup
+    if (conversationIds.size > 0) {
+      conversationIds.forEach(convId => {
+        this.sendMessage({
+          type: 'conv.get',
+          id: convId,
+          timestamp: Date.now()
+        }).catch(() => {
+          // Silently ignore query failures - server will send streaming_start
+          // on subscription confirmation if execution is active
+        });
+      });
+    }
   }
 
   unsubscribeFromSession(sessionId) {