agentgui 1.0.616 → 1.0.618

package/scripts/patch-fsbrowse.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 /**
  * Patch script to fix Windows path duplication issue in fsbrowse
+ * and sync fsbrowse styling with AgentGUI dark mode theme
  * Fixes: Error ENOENT: no such file or directory, scandir 'C:\C:\dev'
  */
 
@@ -54,10 +55,10 @@ try {
     // to avoid duplication like C:\\C:\\dev
     if (baseDriveLetter && sanitizedIsAbsoluteOnDrive && sanitizedDriveLetter === baseDriveLetter) {
       // Remove drive letter and leading slashes to make it relative
-      let relativePath = sanitized;
-      if (/^[A-Z]:/i.test(relativePath)) {
-        relativePath = relativePath.substring(2);
-        if (relativePath[0] === '/' || relativePath[0] === String.fromCharCode(92)) relativePath = relativePath.substring(1);
+      let relativePath = sanitized;
+      if (/^[A-Z]:/i.test(relativePath)) {
+        relativePath = relativePath.substring(2);
+        if (relativePath[0] === '/' || relativePath[0] === String.fromCharCode(92)) relativePath = relativePath.substring(1);
       }
       fullPath = path.resolve(normalizedBase, relativePath);
     } else {
@@ -90,3 +91,129 @@ try {
   console.error('[PATCH] Error applying fsbrowse patch:', err.message);
   process.exit(1);
 }
+
+// Patch fsbrowse CSS for dark mode theme sync
+const fsbrowseCSSPath = path.join(__dirname, '..', 'node_modules', 'fsbrowse', 'public', 'style.css');
+
+if (fs.existsSync(fsbrowseCSSPath)) {
+  try {
+    let cssContent = fs.readFileSync(fsbrowseCSSPath, 'utf8');
+
+    // Check if dark mode CSS is already patched
+    if (cssContent.includes('html.dark {')) {
+      console.log('[PATCH] fsbrowse dark mode CSS already patched');
+    } else {
+      // Inject dark mode CSS rules
+      const darkModeCSS = `/* Light mode - explicit */
+html.light {
+  --primary: #3b82f6;
+  --primary-dark: #2563eb;
+  --secondary: #6b7280;
+  --border: #e5e7eb;
+  --bg: #ffffff;
+  --bg-alt: #f9fafb;
+  --text: #111827;
+  --text-light: #6b7280;
+  --danger: #ef4444;
+}
+
+/* Dark mode - explicit, matches AgentGUI grey dark theme */
+html.dark {
+  --primary: #737373;
+  --primary-dark: #525252;
+  --secondary: #a3a3a3;
+  --border: #333333;
+  --bg: #1a1a1a;
+  --bg-alt: #242424;
+  --text: #e5e5e5;
+  --text-light: #a3a3a3;
+  --danger: #ef4444;
+}
+
+/* Fallback: media query for dark mode preference */
+@media (prefers-color-scheme: dark) {
+  :root:not(.light) {
+    --primary: #60a5fa;
+    --primary-dark: #3b82f6;
+    --secondary: #9ca3af;
+    --border: #374151;
+    --bg: #111827;
+    --bg-alt: #1f2937;
+    --text: #f3f4f6;
+    --text-light: #9ca3af;
+    --danger: #f87171;
+  }
+}`;
+
+      // Find the closing brace of :root and insert after it
+      cssContent = cssContent.replace(
+        /:root \{[\s\S]*?\}\s*@media/,
+        match => match.replace('@media', darkModeCSS + '\n@media')
+      );
+
+      fs.writeFileSync(fsbrowseCSSPath, cssContent, 'utf8');
+      console.log('[PATCH] fsbrowse dark mode CSS patched successfully');
+    }
+  } catch (err) {
+    console.warn('[PATCH] Could not patch fsbrowse CSS:', err.message);
+  }
+}
+
+// Patch fsbrowse app.js for theme sync
+const fsbrowseAppJSPath = path.join(__dirname, '..', 'node_modules', 'fsbrowse', 'public', 'app.js');
+
+if (fs.existsSync(fsbrowseAppJSPath)) {
+  try {
+    let appContent = fs.readFileSync(fsbrowseAppJSPath, 'utf8');
+
+    // Check if theme sync is already patched
+    if (appContent.includes('setupThemeSync')) {
+      console.log('[PATCH] fsbrowse theme sync already patched');
+    } else {
+      // Inject setupThemeSync call and method
+      const themeSyncMethod = `
+  setupThemeSync() {
+    // Sync theme from parent window/localStorage if available
+    const syncTheme = () => {
+      const theme = localStorage.getItem('gmgui-theme') ||
+                    (window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light');
+      document.documentElement.className = theme;
+      document.documentElement.setAttribute('data-theme', theme);
+    };
+
+    syncTheme();
+
+    // Watch for storage changes from other tabs/windows
+    window.addEventListener('storage', e => {
+      if (e.key === 'gmgui-theme') syncTheme();
+    });
+
+    // Watch for media query changes
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', syncTheme);
+  },`;
+
+      // Add setupThemeSync call to init()
+      appContent = appContent.replace(
+        'async init() {',
+        'async init() {\n    this.setupThemeSync();'
+      );
+
+      // Add setupThemeSync method after init()
+      appContent = appContent.replace(
+        'async init() {\n    this.setupThemeSync();\n    this.setupDragDrop();',
+        'async init() {\n    this.setupThemeSync();\n    this.setupDragDrop();'
+      );
+
+      // Insert the method after the api() method
+      appContent = appContent.replace(
+        'api(path) {\n    return `${this.basePath}${path}`;\n  },',
+        'api(path) {\n    return `${this.basePath}${path}`;\n  },' + themeSyncMethod
+      );
+
+      fs.writeFileSync(fsbrowseAppJSPath, appContent, 'utf8');
+      console.log('[PATCH] fsbrowse theme sync patched successfully');
+    }
+  } catch (err) {
+    console.warn('[PATCH] Could not patch fsbrowse app.js:', err.message);
+  }
+}

package/server.js

@@ -372,37 +372,63 @@ expressApp.post(BASE_URL + '/api/upload/:conversationId', (req, res) => {
   }
 });
 
+// Cache fsbrowse routers per conversation to ensure API calls work
+const fsbrowseRouters = new Map();
+
 // fsbrowse file browser - mounted per conversation workingDirectory
 // Route: /gm/files/:conversationId/*
 expressApp.use(BASE_URL + '/files/:conversationId', (req, res, next) => {
-  const conv = queries.getConversation(req.params.conversationId);
+  const convId = req.params.conversationId;
+  const conv = queries.getConversation(convId);
   if (!conv || !conv.workingDirectory) {
     return res.status(404).json({ error: 'Conversation not found or no working directory' });
   }
+
   // Normalize the working directory path to avoid Windows path duplication issues
   const normalizedWorkingDir = path.resolve(conv.workingDirectory);
-  // Create a fresh fsbrowse router for this conversation's directory
-  const router = fsbrowse({ baseDir: normalizedWorkingDir, name: 'Files' });
-  // Strip the conversationId param from the path before passing to fsbrowse
-  req.baseUrl = BASE_URL + '/files/' + req.params.conversationId;
+
+  // Get or create cached fsbrowse router for this conversation
+  let router = fsbrowseRouters.get(convId);
+  if (!router) {
+    router = fsbrowse({ baseDir: normalizedWorkingDir, name: 'Files' });
+    fsbrowseRouters.set(convId, router);
+  }
+
+  // Set baseUrl before calling the router
+  req.baseUrl = BASE_URL + '/files/' + convId;
+  req.url = req.url.replace(new RegExp(`^${BASE_URL}/files/${convId}`), '');
+
   router(req, res, next);
 });
 
 function findCommand(cmd) {
   const isWindows = os.platform() === 'win32';
   const localBin = path.join(path.dirname(fileURLToPath(import.meta.url)), 'node_modules', '.bin', isWindows ? cmd + '.cmd' : cmd);
-  if (fs.existsSync(localBin)) return localBin;
+  if (fs.existsSync(localBin)) {
+    console.log(`[agent-discovery] Found ${cmd} in local node_modules`);
+    return localBin;
+  }
   try {
+    // Increase timeout to 10 seconds to handle slower systems and running agents
+    const timeoutMs = 10000;
     if (isWindows) {
-      const result = execSync(`where ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-      return result.split('\n')[0].trim();
+      const result = execSync(`where ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'], timeout: timeoutMs }).trim();
+      if (result) {
+        console.log(`[agent-discovery] Found ${cmd} in PATH`);
+        return result.split('\n')[0].trim();
+      }
     } else {
-      const result = execSync(`which ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-      return result;
+      const result = execSync(`which ${cmd}`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'], timeout: timeoutMs }).trim();
+      if (result) {
+        console.log(`[agent-discovery] Found ${cmd} in PATH`);
+        return result;
+      }
     }
-  } catch (_) {
+  } catch (err) {
+    console.log(`[agent-discovery] ${cmd} not found or timed out`);
     return null;
   }
+  return null;
 }
 
 async function queryACPServerAgents(baseUrl) {
@@ -479,7 +505,11 @@ function discoverAgents() {
     if (result) {
       agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: result, protocol: bin.protocol });
     } else if (bin.npxPackage) {
+      // For npx-launchable packages (including claude-code as fallback)
       agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: bin.npxPackage, npxLaunchable: true });
+    } else if (bin.id === 'claude-code') {
+      // Ensure Claude Code is always available as an npx-launchable agent
+      agents.push({ id: bin.id, name: bin.name, icon: bin.icon, path: null, protocol: bin.protocol, npxPackage: '@anthropic-ai/claude-code', npxLaunchable: true });
     }
   }
   return agents;
@@ -497,9 +527,23 @@ async function discoverExternalACPServers() {
   return externalAgents;
 }
 
-const discoveredAgents = discoverAgents();
+let discoveredAgents = [];
 initializeDescriptors(discoveredAgents);
 
+// Agent discovery happens asynchronously in background to not block startup
+async function initializeAgentDiscovery() {
+  try {
+    discoveredAgents = discoverAgents();
+    initializeDescriptors(discoveredAgents);
+    console.log('[AGENTS] Discovered:', discoveredAgents.map(a => ({ id: a.id, found: !!a.path })));
+  } catch (err) {
+    console.error('[AGENTS] Discovery error:', err.message);
+  }
+}
+
+// Start immediately but don't wait for it
+initializeAgentDiscovery().catch(() => {});
+
 const modelCache = new Map();
 
 async function getModelsForAgent(agentId) {
@@ -1031,11 +1075,23 @@ const server = http.createServer(async (req, res) => {
 
   if (req.url === '/') { res.writeHead(302, { Location: BASE_URL + '/' }); res.end(); return; }
 
-  if (!req.url.startsWith(BASE_URL + '/') && req.url !== BASE_URL) {
+  // Handle requests with or without BASE_URL prefix (for reverse proxy compatibility)
+  let routePath = req.url;
+  if (req.url.startsWith(BASE_URL + '/')) {
+    routePath = req.url.slice(BASE_URL.length);
+  } else if (req.url === BASE_URL) {
+    routePath = '/';
+  } else if (req.url.startsWith('/api/') || req.url.startsWith('/js/') || req.url.startsWith('/css/') ||
+             req.url.startsWith('/vendor/') || req.url.startsWith('/sync') || req.url === '/' ||
+             req.url.startsWith('/conversations/')) {
+    // Allow requests without BASE_URL prefix for static files and known routes
+    // This supports reverse proxies that strip the BASE_URL prefix
+    routePath = req.url;
+  } else {
     res.writeHead(404); res.end('Not found'); return;
   }
 
-  const routePath = req.url.slice(BASE_URL.length) || '/';
+  routePath = routePath || '/';
 
   try {
     // Remove query parameters from routePath for matching
@@ -1833,21 +1889,44 @@ const server = http.createServer(async (req, res) => {
 
     if (pathOnly === '/api/tools' && req.method === 'GET') {
       console.log('[TOOLS-API] Handling GET /api/tools');
-      const tools = await toolManager.getAllToolsAsync();
-      const result = tools.map((t) => ({
-        id: t.id,
-        name: t.name,
-        pkg: t.pkg,
-        category: t.category || 'plugin',
-        installed: t.installed,
-        status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
-        isUpToDate: t.isUpToDate,
-        upgradeNeeded: t.upgradeNeeded,
-        hasUpdate: t.upgradeNeeded && t.installed,
-        installedVersion: t.installedVersion,
-        publishedVersion: t.publishedVersion
-      }));
-      sendJSON(req, res, 200, { tools: result });
+      try {
+        // Return immediately with cached data (non-blocking) - skip network version checks
+        const tools = await Promise.race([
+          toolManager.getAllToolsAsync(true), // skipPublishedVersion=true for fast response
+          new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 5000))
+        ]);
+        const result = tools.map((t) => ({
+          id: t.id,
+          name: t.name,
+          pkg: t.pkg,
+          category: t.category || 'plugin',
+          installed: t.installed,
+          status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
+          isUpToDate: t.isUpToDate,
+          upgradeNeeded: t.upgradeNeeded,
+          hasUpdate: t.upgradeNeeded && t.installed,
+          installedVersion: t.installedVersion,
+          publishedVersion: t.publishedVersion
+        }));
+        sendJSON(req, res, 200, { tools: result });
+      } catch (err) {
+        console.log('[TOOLS-API] Error getting tools, returning cached status:', err.message);
+        // Return synchronously cached tool status - this provides immediate response with last-known status
+        const tools = toolManager.getAllToolsSync().map((t) => ({
+          id: t.id,
+          name: t.name,
+          pkg: t.pkg,
+          category: t.category || 'plugin',
+          installed: t.installed || false,
+          status: (t.installed) ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed',
+          isUpToDate: t.isUpToDate || false,
+          upgradeNeeded: t.upgradeNeeded || false,
+          hasUpdate: (t.upgradeNeeded && t.installed) || false,
+          installedVersion: t.installedVersion || null,
+          publishedVersion: t.publishedVersion || null
+        }));
+        sendJSON(req, res, 200, { tools });
+      }
       return;
     }
 
@@ -3425,6 +3504,7 @@ function serveFile(filePath, res, req) {
     const baseTag = `<script>window.__BASE_URL='${BASE_URL}';</script>`;
     content = content.replace('<head>', `<head>\n  <base href="${BASE_URL}/">\n  ` + baseTag);
     content = content.replace(/(href|src)="vendor\//g, `$1="${BASE_URL}/vendor/`);
+    content = content.replace(/(src)="\/gm\/js\//g, `$1="${BASE_URL}/js/`);
     if (watch) {
       content += `\n<script>(function(){const ws=new WebSocket((location.protocol==='https:'?'wss://':'ws://')+location.host+'${BASE_URL}/hot-reload');ws.onmessage=e=>{if(JSON.parse(e.data).type==='reload')location.reload()};})();</script>`;
     }
@@ -4155,6 +4235,7 @@ const BROADCAST_TYPES = new Set([
   'streaming_start', 'streaming_progress', 'streaming_complete', 'streaming_error',
   'tool_install_started', 'tool_install_progress', 'tool_install_complete', 'tool_install_failed',
   'tool_update_progress', 'tool_update_complete', 'tool_update_failed',
+  'tool_status_update',
   'tools_update_started', 'tools_update_complete', 'tools_refresh_complete',
   'pm2_monit_update', 'pm2_monitoring_started', 'pm2_monitoring_stopped',
   'pm2_list_response', 'pm2_start_response', 'pm2_stop_response',
@@ -4219,7 +4300,7 @@ registerUtilHandlers(wsRouter, {
   broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
   startGeminiOAuth, exchangeGeminiOAuthCode,
   geminiOAuthState: () => geminiOAuthState,
-  STARTUP_CWD, activeScripts, voiceCacheManager, toolManager
+  STARTUP_CWD, activeScripts, voiceCacheManager, toolManager, discoveredAgents
 });
 
 wsRouter.onLegacy((data, ws) => {
@@ -4508,13 +4589,12 @@ server.on('error', (err) => {
 function recoverStaleSessions() {
   try {
     const now = Date.now();
+    const RESUME_WINDOW_MS = 600000; // 10 minutes
 
     const resumable = new Set();
-    const resumableConvs = queries.getResumableConversations ? queries.getResumableConversations() : [];
+    const resumableConvs = queries.getResumableConversations ? queries.getResumableConversations(RESUME_WINDOW_MS) : [];
     for (const conv of resumableConvs) {
-      if (conv.agentType === 'claude-code') {
-        resumable.add(conv.id);
-      }
+      resumable.add(conv.id); // All agent types are resumable
     }
 
     const staleSessions = queries.getActiveSessions ? queries.getActiveSessions() : [];
@@ -4554,23 +4634,29 @@ function recoverStaleSessions() {
 
 async function resumeInterruptedStreams() {
   try {
+    const RESUME_WINDOW_MS = 600000; // Only resume sessions active within the last 10 minutes
+    const cutoff = Date.now() - RESUME_WINDOW_MS;
+
     // Get conversations marked as streaming in database (isStreaming=1)
     // Fall back to getResumableConversations if isStreaming is not being used
     let toResume = [];
 
     // Primary: Check database isStreaming flag for conversations still marked as active
-    // Exclude conversations whose last session completed - they should not be resumed
+    // Exclude conversations whose last session completed or started more than 10 min ago
     const streamingConvs = queries.getConversations().filter(c => {
       if (c.isStreaming !== 1) return false;
       const lastSession = queries.getLatestSession(c.id);
-      return !lastSession || lastSession.status !== 'complete';
+      if (!lastSession) return false;
+      if (lastSession.status === 'complete') return false;
+      // Only resume if session started within the last 10 minutes
+      return lastSession.started_at > cutoff;
     });
 
     if (streamingConvs.length > 0) {
       toResume = streamingConvs;
     } else {
-      // Fallback: Use session-based resumable conversations
-      toResume = queries.getResumableConversations ? queries.getResumableConversations() : [];
+      // Fallback: Use session-based resumable conversations (already filtered by 10 min)
+      toResume = queries.getResumableConversations ? queries.getResumableConversations(RESUME_WINDOW_MS) : [];
     }
 
     if (toResume.length === 0) return;
@@ -4580,87 +4666,13 @@ async function resumeInterruptedStreams() {
     for (let i = 0; i < toResume.length; i++) {
       const conv = toResume[i];
       try {
-        // Find previous incomplete sessions to load checkpoint from
         const previousSessions = [...queries.getSessionsByStatus(conv.id, 'active'), ...queries.getSessionsByStatus(conv.id, 'pending')];
         const previousSessionId = previousSessions.length > 0 ? previousSessions[0].id : null;
-
-        // Load checkpoint from previous session
-        const checkpoint = previousSessionId ? checkpointManager.loadCheckpoint(previousSessionId) : null;
-
-        for (const s of previousSessions) {
-          queries.updateSession(s.id, { status: 'interrupted', error: 'Server restarted, resuming', completed_at: Date.now() });
-        }
-
-        const lastMsg = queries.getLastUserMessage(conv.id);
-        const prompt = lastMsg?.content || 'continue';
-        const promptText = typeof prompt === 'string' ? prompt : JSON.stringify(prompt);
-
-        const session = queries.createSession(conv.id);
-        queries.createEvent('session.created', {
-          sessionId: session.id,
-          resumeReason: 'server_restart',
-          claudeSessionId: conv.claudeSessionId,
-          checkpointFrom: previousSessionId
-        }, conv.id, session.id);
-
-        activeExecutions.set(conv.id, {
-          pid: null,
-          startTime: Date.now(),
-          sessionId: session.id,
-          lastActivity: Date.now()
-        });
-
-        broadcastSync({
-          type: 'streaming_start',
-          sessionId: session.id,
-          conversationId: conv.id,
-          agentId: conv.agentType,
-          resumed: true,
-          checkpointAvailable: !!checkpoint,
-          timestamp: Date.now()
-        });
-
-        // Store checkpoint to inject when client subscribes (not now, since no clients connected yet)
-        if (checkpoint) {
-          checkpointManager.storeCheckpointForDelay(conv.id, checkpoint);
-          checkpointManager.markSessionResumed(previousSessionId);
-          console.log(`[RESUME] Checkpoint stored for ${conv.id}, will inject on next client subscribe`);
-        }
-
-        const messageId = lastMsg?.id || null;
-        console.log(`[RESUME] Resuming conv ${conv.id} (claude session: ${conv.claudeSessionId}) with checkpoint=${!!checkpoint}`);
-
-        try {
-          await processMessageWithStreaming(conv.id, messageId, session.id, promptText, conv.agentType, conv.model, conv.subAgent);
-        } catch (err) {
-          console.error(`[RESUME] Error resuming conv ${conv.id}: ${err.message}`);
-          queries.setIsStreaming(conv.id, false);
-          const activeSessions = queries.getSessionsByStatus(conv.id, 'active');
-          const pendingSessions = queries.getSessionsByStatus(conv.id, 'pending');
-          for (const s of [...activeSessions, ...pendingSessions]) {
-            queries.updateSession(s.id, {
-              status: 'error',
-              error: 'Resume failed: ' + err.message,
-              completed_at: Date.now()
-            });
-          }
-        }
-
-        if (i < toResume.length - 1) {
-          await new Promise(r => setTimeout(r, 200));
-        }
+        await resumeConversation(conv.id, previousSessionId, 'Server restarted, resuming');
+        if (i < toResume.length - 1) await new Promise(r => setTimeout(r, 200));
       } catch (err) {
         console.error(`[RESUME] Failed to resume conv ${conv.id}: ${err.message}`);
         queries.setIsStreaming(conv.id, false);
-        const activeSessions = queries.getSessionsByStatus(conv.id, 'active');
-        const pendingSessions = queries.getSessionsByStatus(conv.id, 'pending');
-        for (const s of [...activeSessions, ...pendingSessions]) {
-          queries.updateSession(s.id, {
-            status: 'error',
-            error: 'Resume failed: ' + err.message,
-            completed_at: Date.now()
-          });
-        }
       }
     }
   } catch (err) {
@@ -4681,14 +4693,29 @@ function isProcessAlive(pid) {
 function markAgentDead(conversationId, entry, reason) {
   if (!activeExecutions.has(conversationId)) return;
   activeExecutions.delete(conversationId);
+
+  const RESUME_WINDOW_MS = 600000; // 10 minutes
+  const sessionAge = entry.startTime ? Date.now() - entry.startTime : Infinity;
+  const shouldRestart = sessionAge < RESUME_WINDOW_MS;
+
   queries.setIsStreaming(conversationId, false);
   if (entry.sessionId) {
     queries.updateSession(entry.sessionId, {
-      status: 'error',
+      status: shouldRestart ? 'interrupted' : 'error',
       error: reason,
       completed_at: Date.now()
     });
   }
+
+  if (shouldRestart) {
+    // Session was recent — restart it automatically
+    resumeConversation(conversationId, entry.sessionId, reason).catch(err => {
+      console.error(`[RESUME] Auto-restart failed for conv ${conversationId}: ${err.message}`);
+      queries.setIsStreaming(conversationId, false);
+    });
+    return;
+  }
+
   broadcastSync({
     type: 'streaming_error',
     sessionId: entry.sessionId,
@@ -4700,6 +4727,61 @@ function markAgentDead(conversationId, entry, reason) {
   drainMessageQueue(conversationId);
 }
 
+// Resume a single conversation after interruption. Used both by markAgentDead and resumeInterruptedStreams.
+async function resumeConversation(conversationId, previousSessionId, reason) {
+  const conv = queries.getConversation(conversationId);
+  if (!conv) throw new Error('Conversation not found');
+
+  const checkpoint = previousSessionId ? checkpointManager.loadCheckpoint(previousSessionId) : null;
+
+  if (previousSessionId) {
+    // Only mark interrupted if not already done
+    const prev = queries.getSession ? queries.getSession(previousSessionId) : null;
+    if (prev && prev.status !== 'interrupted') {
+      queries.updateSession(previousSessionId, { status: 'interrupted', error: reason || 'Restarting', completed_at: Date.now() });
+    }
+    if (checkpoint) {
+      checkpointManager.markSessionResumed(previousSessionId);
+    }
+  }
+
+  const lastMsg = queries.getLastUserMessage(conversationId);
+  const promptText = typeof lastMsg?.content === 'string' ? lastMsg.content : JSON.stringify(lastMsg?.content || 'continue');
+
+  const session = queries.createSession(conversationId);
+  queries.createEvent('session.created', {
+    sessionId: session.id,
+    resumeReason: 'interrupted',
+    claudeSessionId: conv.claudeSessionId,
+    checkpointFrom: previousSessionId || null
+  }, conversationId, session.id);
+
+  activeExecutions.set(conversationId, {
+    pid: null,
+    startTime: Date.now(),
+    sessionId: session.id,
+    lastActivity: Date.now()
+  });
+
+  broadcastSync({
+    type: 'streaming_start',
+    sessionId: session.id,
+    conversationId,
+    agentId: conv.agentType,
+    resumed: true,
+    checkpointAvailable: !!checkpoint,
+    timestamp: Date.now()
+  });
+
+  if (checkpoint) {
+    checkpointManager.storeCheckpointForDelay(conversationId, checkpoint);
+    console.log(`[RESUME] Checkpoint stored for conv ${conversationId}`);
+  }
+
+  console.log(`[RESUME] Restarting conv ${conversationId} (reason: ${reason})`);
+  await processMessageWithStreaming(conversationId, lastMsg?.id || null, session.id, promptText, conv.agentType, conv.model, conv.subAgent);
+}
+
 function performAgentHealthCheck() {
   const now = Date.now();
   for (const [conversationId, entry] of activeExecutions) {
@@ -4725,6 +4807,9 @@ function performAgentHealthCheck() {
 }
 
 function onServerReady() {
+  // Clear tool status cache on startup to ensure fresh detection
+  toolManager.clearStatusCache();
+
   console.log(`GMGUI running on http://localhost:${PORT}${BASE_URL}/`);
   console.log(`Agents: ${discoveredAgents.map(a => a.name).join(', ') || 'none'}`);
   console.log(`Hot reload: ${watch ? 'on' : 'off'}`);
@@ -4768,6 +4853,11 @@ function onServerReady() {
     } else if (evt.type === 'tool_install_failed' || evt.type === 'tool_update_failed') {
       queries.updateToolStatus(evt.toolId, { status: 'failed', error_message: evt.data?.error });
       queries.addToolInstallHistory(evt.toolId, evt.type.includes('update') ? 'update' : 'install', 'failed', evt.data?.error);
+    } else if (evt.type === 'tool_status_update') {
+      const d = evt.data || {};
+      if (d.installed) {
+        queries.updateToolStatus(evt.toolId, { status: 'installed', version: d.installedVersion || null, installed_at: Date.now() });
+      }
     }
   }).catch(err => console.error('[TOOLS] Auto-provision error:', err.message));