agentgui 1.0.835 → 1.0.836

package/CHANGELOG.md

@@ -1,6 +1,8 @@
 ## [Unreleased]
 
 ### Refactor
+- refactor: extract broadcastSync to lib/broadcast.js (createBroadcast factory) and recovery functions to lib/recovery.js (createRecovery factory); server.js reduced from 3419L to 3226L
+- refactor: remove JSDoc and standalone code comments from scripts/patch-fsbrowse.js; reduce from 229L to 200L
 - Split database.js (651L) into database.js (81L) + database-schema.js (176L) + database-migrations.js (150L) + database-migrations-acp.js (134L); all files ≤200L; no circular imports; migration functions receive db as parameter
 - Split claude-runner.js (1267L) into claude-runner.js (56L, AgentRunner class+helpers), claude-runner-direct.js (117L, runDirect method), claude-runner-acp.js (156L, runACP+_runACPOnce methods), claude-runner-agents.js (105L, AgentRegistry+registrations using acp-protocol.js), claude-runner-run.js (50L, runClaudeWithStreaming export); server.js updated to import from claude-runner-run.js
 - Split db-queries.js (1413L) into db-queries.js (93L, factory + conv queries), db-queries-messages.js (103L), db-queries-sessions.js (113L), db-queries-events.js (69L), db-queries-del.js (143L), db-queries-cleanup.js (86L), db-queries-import.js (134L), db-queries-streams.js (101L), db-queries-chunks.js (196L), db-queries-chunks2.js (83L), db-queries-voice.js (86L), db-queries-tools.js (128L); all ≤200L; each exports addXxxQueries(q, db, prep, generateId); factory calls all helpers and returns q

package/lib/broadcast.js

@@ -0,0 +1,28 @@
+export function createBroadcast({ syncClients, subscriptionIndex, wsOptimizer, broadcastTypes, getSeq }) {
+  return function broadcastSync(event) {
+    try {
+      if (!event.seq) {
+        event.seq = getSeq();
+      }
+      const isBroadcast = broadcastTypes.has(event.type);
+      if (syncClients.size > 0) {
+        if (isBroadcast) {
+          for (const ws of syncClients) { try { wsOptimizer.sendToClient(ws, event); } catch (e) {} }
+        } else {
+          const targets = new Set();
+          if (event.sessionId) {
+            const subs = subscriptionIndex.get(event.sessionId);
+            if (subs) for (const ws of subs) targets.add(ws);
+          }
+          if (event.conversationId) {
+            const subs = subscriptionIndex.get(`conv-${event.conversationId}`);
+            if (subs) for (const ws of subs) targets.add(ws);
+          }
+          for (const ws of targets) { try { wsOptimizer.sendToClient(ws, event); } catch (e) {} }
+        }
+      }
+    } catch (err) {
+      console.error('[BROADCAST] Error (contained):', err.message);
+    }
+  };
+}

package/lib/recovery.js

@@ -0,0 +1,166 @@
+export function createRecovery({ activeExecutions, processMessageWithStreaming, queries, broadcastSync, checkpointManager, drainMessageQueue, stuckThresholdMs, noPidGracePeriodMs }) {
+  function isProcessAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (err) {
+      if (err.code === 'EPERM') return true;
+      return false;
+    }
+  }
+
+  function killActiveExecutions() {
+    for (const [convId, entry] of activeExecutions.entries()) {
+      if (entry.pid) {
+        try { process.kill(-entry.pid, 'SIGTERM'); } catch { try { process.kill(entry.pid, 'SIGTERM'); } catch (_) {} }
+      }
+      if (entry.proc) {
+        try { entry.proc.kill('SIGTERM'); } catch (_) {}
+      }
+    }
+    activeExecutions.clear();
+  }
+
+  function recoverStaleSessions() {
+    try {
+      const RESUME_WINDOW_MS = 600000;
+      const cutoff = Date.now() - RESUME_WINDOW_MS;
+      const staleSessions = queries.getActiveSessions();
+      for (const session of staleSessions) {
+        queries.updateSession(session.id, {
+          status: session.started_at > cutoff ? 'interrupted' : 'error',
+          error: 'Server restarted',
+          completed_at: Date.now()
+        });
+      }
+      queries.clearAllStreamingFlags();
+      if (staleSessions.length > 0) {
+        console.log(`[RECOVERY] Marked ${staleSessions.length} stale session(s); cleared streaming flags`);
+      }
+    } catch (err) {
+      console.error('[RECOVERY] Error:', err.message);
+    }
+  }
+
+  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) {
+      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 markAgentDead(conversationId, entry, reason) {
+    if (!activeExecutions.has(conversationId)) return;
+    activeExecutions.delete(conversationId);
+    const RESUME_WINDOW_MS = 600000;
+    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: shouldRestart ? 'interrupted' : 'error',
+        error: reason,
+        completed_at: Date.now()
+      });
+    }
+    if (shouldRestart) {
+      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,
+      conversationId,
+      error: reason,
+      recoverable: false,
+      timestamp: Date.now()
+    });
+    drainMessageQueue(conversationId);
+  }
+
+  async function resumeInterruptedStreams() {
+    try {
+      const toResume = queries.getResumableConversations(600000);
+      if (toResume.length === 0) return;
+      console.log(`[RESUME] Resuming ${toResume.length} interrupted conversation(s)`);
+      for (let i = 0; i < toResume.length; i++) {
+        const conv = toResume[i];
+        try {
+          const lastSession = queries.getLatestSession(conv.id);
+          await resumeConversation(conv.id, lastSession?.id || null, 'Server restarted');
+          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);
+        }
+      }
+    } catch (err) {
+      console.error('[RESUME] Error:', err.message);
+    }
+  }
+
+  function performAgentHealthCheck() {
+    const now = Date.now();
+    for (const [conversationId, entry] of activeExecutions) {
+      if (!entry) continue;
+      if (entry.pid) {
+        if (!isProcessAlive(entry.pid)) {
+          console.error(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} is dead`);
+          markAgentDead(conversationId, entry, 'Agent process died unexpectedly');
+        } else if (now - entry.lastActivity > stuckThresholdMs) {
+          console.error(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} has no activity for ${Math.round((now - entry.lastActivity) / 1000)}s`);
+          try { process.kill(entry.pid, 'SIGTERM'); } catch (e) {}
+          markAgentDead(conversationId, entry, 'Agent was stuck (no activity for 30 minutes)');
+        }
+      } else {
+        if (now - entry.startTime > noPidGracePeriodMs) {
+          console.error(`[HEALTH] Agent for conv ${conversationId} never reported PID after ${Math.round((now - entry.startTime) / 1000)}s`);
+          markAgentDead(conversationId, entry, 'Agent failed to start (no PID reported)');
+        }
+      }
+    }
+  }
+
+  return { killActiveExecutions, recoverStaleSessions, resumeInterruptedStreams, isProcessAlive, markAgentDead, resumeConversation, performAgentHealthCheck };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.835",
+  "version": "1.0.836",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/scripts/patch-fsbrowse.js

@@ -1,16 +1,9 @@
 #!/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'
- */
-
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 const fsbrowsePath = path.join(__dirname, '..', 'node_modules', 'fsbrowse', 'index.js');
 
 if (!fs.existsSync(fsbrowsePath)) {
@@ -21,13 +14,11 @@ if (!fs.existsSync(fsbrowsePath)) {
 try {
   let content = fs.readFileSync(fsbrowsePath, 'utf8');
 
-  // Check if patch is already applied
   if (content.includes('sanitizedIsAbsoluteOnDrive')) {
     console.log('[PATCH] fsbrowse Windows path fix already applied');
     process.exit(0);
   }
 
-  // Replace the makeResolver function with the fixed version
   const oldMakeResolver = `function makeResolver(baseDir) {
   return function resolveWithBaseDir(relPath) {
     const sanitized = sanitizePath(relPath);
@@ -46,15 +37,10 @@ try {
   return function resolveWithBaseDir(relPath) {
     const sanitized = sanitizePath(relPath);
     let fullPath;
-
-    // Extract drive letter from both paths to check for same-drive duplication on Windows
     const sanitizedDriveLetter = sanitized.match(/^[A-Z]:/i)?.[0];
     const sanitizedIsAbsoluteOnDrive = /^[A-Z]:/i.test(sanitized);
 
-    // If both paths are on the same Windows drive, strip the drive letter from relPath
-    // 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);
@@ -65,11 +51,8 @@ try {
       fullPath = path.resolve(normalizedBase, sanitized);
     }
 
-    // Normalize for consistent comparison
     const normalizedFullPath = path.normalize(fullPath);
     const normalizedComparisonBase = path.normalize(normalizedBase);
-
-    // Check path injection - convert backslashes to forward slashes for comparison
     const normalizedCheck = normalizedFullPath.replace(/\\\\/g, '/');
     const normalizedBaseCheck = normalizedComparisonBase.replace(/\\\\/g, '/');
 
@@ -92,18 +75,14 @@ try {
   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;
@@ -145,7 +124,6 @@ html.dark {
   }
 }`;
 
-      // 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')
@@ -159,23 +137,18 @@ html.dark {
   }
 }
 
-// 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');
 
-    // Ensure postMessage theme listener is present (storage events don't fire in same-window iframes)
     if (appContent.includes('theme-change')) {
       console.log('[PATCH] fsbrowse postMessage theme sync already present');
     } else if (appContent.includes('setupThemeSync')) {
-      // setupThemeSync exists but lacks postMessage support - inject it
       appContent = appContent.replace(
         "    // Watch for storage changes from other tabs/windows\n    window.addEventListener('storage', e => {\n      if (e.key === 'gmgui-theme') syncTheme();\n    });",
         "    // Watch for storage changes from other tabs/windows\n    window.addEventListener('storage', e => {\n      if (e.key === 'gmgui-theme') syncTheme();\n    });\n\n    // Watch for postMessage from parent window (same-window iframes don't receive storage events)\n    window.addEventListener('message', e => {\n      if (e.data && e.data.type === 'theme-change' && e.data.theme) syncTheme(e.data.theme);\n    });"
       );
-      // Also make syncTheme accept an explicit theme argument
       appContent = appContent.replace(
         'const syncTheme = () => {\n      const theme = localStorage.getItem(\'gmgui-theme\') ||',
         'const syncTheme = (theme) => {\n      theme = theme || localStorage.getItem(\'gmgui-theme\') ||'
@@ -183,7 +156,6 @@ if (fs.existsSync(fsbrowseAppJSPath)) {
       fs.writeFileSync(fsbrowseAppJSPath, appContent, 'utf8');
       console.log('[PATCH] fsbrowse postMessage theme sync injected');
     } else {
-      // No setupThemeSync at all - inject full method
       const themeSyncMethod = `
   setupThemeSync() {
     // Sync theme from parent window/localStorage if available

package/server.js

@@ -45,11 +45,14 @@ import { register as registerMsgHandlers } from './lib/ws-handlers-msg.js';
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-sdk-manager.js';
 import * as execMachine from './lib/execution-machine.js';
 import * as toolInstallMachine from './lib/tool-install-machine.js';
+import { _assetCache, htmlState, generateETag, warmAssetCache, serveFile as _serveFile, createChunkBatcher } from './lib/asset-server.js';
 import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
 import * as toolManager from './lib/tool-manager.js';
 import { pm2Manager } from './lib/pm2-manager.js';
 import CheckpointManager from './lib/checkpoint-manager.js';
 import { JsonlWatcher } from './lib/jsonl-watcher.js';
+import { createBroadcast } from './lib/broadcast.js';
+import { createRecovery } from './lib/recovery.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -1651,175 +1654,9 @@ const server = http.createServer(async (req, res) => {
   }
 });
 
-const MIME_TYPES = { '.html': 'text/html; charset=utf-8', '.js': 'application/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8', '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg', '.svg': 'image/svg+xml' };
+const _assetDeps = { compressAndSend, acceptsEncoding, watch, BASE_URL, PKG_VERSION };
+function serveFile(filePath, res, req) { return _serveFile(filePath, res, req, _assetDeps); }
 
-function generateETag(stats) {
-  return `"${stats.mtimeMs.toString(36)}-${stats.size.toString(36)}"`;
-}
-
-// In-memory cache: etag -> { gz: Buffer, raw: Buffer } (bounded to 200 entries)
-const _assetCache = new LRUCache({ max: 200 });
-// Cached processed HTML (invalidated on hot-reload or server restart)
-let _htmlCache = null;
-let _htmlCacheEtag = null;
-
-function warmAssetCache() {
-  const dirs = ['js', 'css', 'lib', 'vendor'];
-  let count = 0;
-  for (const dir of dirs) {
-    const full = path.join(staticDir, dir);
-    if (!fs.existsSync(full)) continue;
-    for (const file of fs.readdirSync(full)) {
-      const filePath = path.join(full, file);
-      try {
-        const stats = fs.statSync(filePath);
-        if (!stats.isFile()) continue;
-        const etag = generateETag(stats);
-        if (_assetCache.has(etag)) continue;
-        const raw = fs.readFileSync(filePath);
-        const entry = raw.length < 860 ? { raw, gz: null } : { raw, gz: zlib.gzipSync(raw, { level: 6 }) };
-        _assetCache.set(etag, entry);
-        count++;
-      } catch (_) {}
-    }
-  }
-  for (const file of ['app.js', 'theme.js']) {
-    const filePath = path.join(staticDir, file);
-    try {
-      const stats = fs.statSync(filePath);
-      const etag = generateETag(stats);
-      if (!_assetCache.has(etag)) {
-        const raw = fs.readFileSync(filePath);
-        _assetCache.set(etag, raw.length < 860 ? { raw, gz: null } : { raw, gz: zlib.gzipSync(raw, { level: 6 }) });
-        count++;
-      }
-    } catch (_) {}
-  }
-  if (count > 0) console.log(`[CACHE] Pre-warmed ${count} static assets`);
-}
-
-function serveFile(filePath, res, req) {
-  const ext = path.extname(filePath).toLowerCase();
-  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
-
-  if (ext !== '.html') {
-    fs.stat(filePath, (err, stats) => {
-      if (err) { res.writeHead(500); res.end('Server error'); return; }
-      const etag = generateETag(stats);
-      if (req && req.headers['if-none-match'] === etag) {
-        res.writeHead(304);
-        res.end();
-        return;
-      }
-      // Use ETag-based revalidation: browser always checks with server, serves from cache on 304
-      // Avoids stale immutable assets when server files change during development
-      const cacheControl = 'public, no-cache';
-
-      const sendCached = (cached) => {
-        if (acceptsEncoding(req, 'gzip') && cached.gz) {
-          res.writeHead(200, { 'Content-Type': contentType, 'Content-Encoding': 'gzip', 'Content-Length': cached.gz.length, 'ETag': etag, 'Cache-Control': cacheControl });
-          res.end(cached.gz);
-        } else {
-          res.writeHead(200, { 'Content-Type': contentType, 'Content-Length': cached.raw.length, 'ETag': etag, 'Cache-Control': cacheControl });
-          res.end(cached.raw);
-        }
-      };
-
-      const cached = _assetCache.get(etag);
-      if (cached) { sendCached(cached); return; }
-
-      fs.readFile(filePath, (err2, raw) => {
-        if (err2) { res.writeHead(500); res.end('Server error'); return; }
-        if (raw.length < 860) {
-          const entry = { raw, gz: null };
-          _assetCache.set(etag, entry);
-          sendCached(entry);
-          return;
-        }
-        // Pre-compress once with gzip, cache it
-        const gz = zlib.gzipSync(raw, { level: 6 });
-        const entry = { raw, gz };
-        _assetCache.set(etag, entry);
-        sendCached(entry);
-      });
-    });
-    return;
-  }
-
-  // HTML: cache processed result, invalidate when file changes
-  fs.stat(filePath, (err, stats) => {
-    if (err) { res.writeHead(500); res.end('Server error'); return; }
-    const etag = generateETag(stats);
-    if (!watch && _htmlCache && _htmlCacheEtag === etag) {
-      res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-store', 'Content-Encoding': 'gzip', 'Content-Length': _htmlCache.length });
-      res.end(_htmlCache);
-      return;
-    }
-    fs.readFile(filePath, (err2, data) => {
-      if (err2) { res.writeHead(500); res.end('Server error'); return; }
-      let content = data.toString();
-      const wsToken = process.env.PASSWORD ? `window.__WS_TOKEN='${process.env.PASSWORD.replace(/'/g, "\\'")}';` : '';
-      const baseTag = `<script>window.__BASE_URL='${BASE_URL}';window.__SERVER_VERSION='${PKG_VERSION}';${wsToken}</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>`;
-      }
-      compressAndSend(req, res, 200, contentType, content);
-      if (!watch && acceptsEncoding(req, 'gzip')) {
-        _htmlCache = zlib.gzipSync(Buffer.from(content), { level: 6 });
-        _htmlCacheEtag = etag;
-      }
-    });
-  });
-}
-
-function createChunkBatcher() {
-  const pending = [];
-  let timer = null;
-  const BATCH_SIZE = 10;
-  const BATCH_INTERVAL = 50;
-
-  function flush() {
-    if (pending.length === 0) return;
-    const batch = pending.splice(0);
-    try {
-      const tx = queries._db ? queries._db.transaction(() => {
-        for (const c of batch) queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data);
-      }) : null;
-      if (tx) { tx(); } else {
-        for (const c of batch) {
-          try { queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data); } catch (e) { debugLog(`[chunk] ${e.message}`); }
-        }
-      }
-    } catch (err) {
-      debugLog(`[chunk-batch] Batch write failed: ${err.message}`);
-      for (const c of batch) {
-        try { queries.createChunk(c.sessionId, c.conversationId, c.sequence, c.type, c.data); } catch (_) {}
-      }
-    }
-  }
-
-  function add(sessionId, conversationId, sequence, blockType, blockData) {
-    pending.push({ sessionId, conversationId, sequence, type: blockType, data: blockData });
-    if (pending.length >= BATCH_SIZE) {
-      if (timer) { clearTimeout(timer); timer = null; }
-      flush();
-    } else if (!timer) {
-      timer = setTimeout(() => { timer = null; flush(); }, BATCH_INTERVAL);
-    }
-  }
-
-  function drain() {
-    if (timer) { clearTimeout(timer); timer = null; }
-    flush();
-  }
-
-  return { add, drain };
-}
-
-// Global broadcast sequence counter for event ordering
 let broadcastSeq = 0;
 
 function parseRateLimitResetTime(text) {
@@ -2580,36 +2417,13 @@ const BROADCAST_TYPES = new Set([
 
 const wsOptimizer = new WSOptimizer();
 
-function broadcastSync(event) {
-  try {
-    // Assign global sequence number to ALL events for ordering guarantee
-    if (!event.seq) {
-      event.seq = ++broadcastSeq;
-    }
-
-    const isBroadcast = BROADCAST_TYPES.has(event.type);
-
-    if (syncClients.size > 0) {
-      if (isBroadcast) {
-        for (const ws of syncClients) { try { wsOptimizer.sendToClient(ws, event); } catch (e) {} }
-      } else {
-        const targets = new Set();
-        if (event.sessionId) {
-          const subs = subscriptionIndex.get(event.sessionId);
-          if (subs) for (const ws of subs) targets.add(ws);
-        }
-        if (event.conversationId) {
-          const subs = subscriptionIndex.get(`conv-${event.conversationId}`);
-          if (subs) for (const ws of subs) targets.add(ws);
-        }
-        for (const ws of targets) { try { wsOptimizer.sendToClient(ws, event); } catch (e) {} }
-      }
-    }
-
-  } catch (err) {
-    console.error('[BROADCAST] Error (contained):', err.message);
-  }
-}
+const broadcastSync = createBroadcast({
+  syncClients,
+  subscriptionIndex,
+  wsOptimizer,
+  broadcastTypes: BROADCAST_TYPES,
+  getSeq: () => ++broadcastSeq
+});
 
 // WebSocket protocol router
 const wsRouter = new WsRouter();
@@ -2953,17 +2767,16 @@ if (watch) {
   } catch (e) { console.error('Watch error:', e.message); }
 }
 
-function killActiveExecutions() {
-  for (const [convId, entry] of activeExecutions.entries()) {
-    if (entry.pid) {
-      try { process.kill(-entry.pid, 'SIGTERM'); } catch { try { process.kill(entry.pid, 'SIGTERM'); } catch (_) {} }
-    }
-    if (entry.proc) {
-      try { entry.proc.kill('SIGTERM'); } catch (_) {}
-    }
-  }
-  activeExecutions.clear();
-}
+const { killActiveExecutions, recoverStaleSessions, resumeInterruptedStreams, isProcessAlive, markAgentDead, resumeConversation, performAgentHealthCheck } = createRecovery({
+  activeExecutions,
+  processMessageWithStreaming,
+  queries,
+  broadcastSync,
+  checkpointManager,
+  drainMessageQueue,
+  stuckThresholdMs: STUCK_AGENT_THRESHOLD_MS,
+  noPidGracePeriodMs: NO_PID_GRACE_PERIOD_MS
+});
 
 process.on('SIGTERM', () => {
   console.log('[SIGNAL] SIGTERM received - graceful shutdown');
@@ -2992,178 +2805,6 @@ server.on('error', (err) => {
   }
 });
 
-// On startup: mark all active/pending sessions as interrupted (server was down, they didn't complete).
-// Then resumeInterruptedStreams will pick up recent ones for auto-resume.
-function recoverStaleSessions() {
-  try {
-    const RESUME_WINDOW_MS = 600000;
-    const cutoff = Date.now() - RESUME_WINDOW_MS;
-    const staleSessions = queries.getActiveSessions();
-    for (const session of staleSessions) {
-      queries.updateSession(session.id, {
-        status: session.started_at > cutoff ? 'interrupted' : 'error',
-        error: 'Server restarted',
-        completed_at: Date.now()
-      });
-    }
-    // Clear all isStreaming flags - nothing is running yet
-    queries.clearAllStreamingFlags();
-    if (staleSessions.length > 0) {
-      console.log(`[RECOVERY] Marked ${staleSessions.length} stale session(s); cleared streaming flags`);
-    }
-  } catch (err) {
-    console.error('[RECOVERY] Error:', err.message);
-  }
-}
-
-// Resume conversations with recently interrupted sessions (started within 10 min).
-async function resumeInterruptedStreams() {
-  try {
-    const toResume = queries.getResumableConversations(600000);
-    if (toResume.length === 0) return;
-    console.log(`[RESUME] Resuming ${toResume.length} interrupted conversation(s)`);
-    for (let i = 0; i < toResume.length; i++) {
-      const conv = toResume[i];
-      try {
-        const lastSession = queries.getLatestSession(conv.id);
-        await resumeConversation(conv.id, lastSession?.id || null, 'Server restarted');
-        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);
-      }
-    }
-  } catch (err) {
-    console.error('[RESUME] Error:', err.message);
-  }
-}
-
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if (err.code === 'EPERM') return true;
-    return false;
-  }
-}
-
-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: 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,
-    conversationId,
-    error: reason,
-    recoverable: false,
-    timestamp: Date.now()
-  });
-  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) {
-    if (!entry) continue;
-
-    if (entry.pid) {
-      if (!isProcessAlive(entry.pid)) {
-        debugLog(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} is dead`);
-        markAgentDead(conversationId, entry, 'Agent process died unexpectedly');
-      } else if (now - entry.lastActivity > STUCK_AGENT_THRESHOLD_MS) {
-        debugLog(`[HEALTH] Agent PID ${entry.pid} for conv ${conversationId} has no activity for ${Math.round((now - entry.lastActivity) / 1000)}s`);
-        // Kill stuck agent and clear streaming state
-        try { process.kill(entry.pid, 'SIGTERM'); } catch (e) {}
-        markAgentDead(conversationId, entry, 'Agent was stuck (no activity for 30 minutes)');
-      }
-    } else {
-      if (now - entry.startTime > NO_PID_GRACE_PERIOD_MS) {
-        debugLog(`[HEALTH] Agent for conv ${conversationId} never reported PID after ${Math.round((now - entry.startTime) / 1000)}s`);
-        markAgentDead(conversationId, entry, 'Agent failed to start (no PID reported)');
-      }
-    }
-  }
-}
-
 let jsonlWatcher = null;
 
 function onServerReady() {