agentgui 1.0.837 → 1.0.838

package/CHANGELOG.md

@@ -1,6 +1,7 @@
 ## [Unreleased]
 
 ### Refactor
+- Extract processMessageWithStreaming (539L), scheduleRetry, drainMessageQueue, and parseRateLimitResetTime from server.js into lib/process-message.js (127L, createProcessMessage factory), lib/stream-event-handler.js (116L, createEventHandler), lib/message-queue.js (63L, createMessageQueue), lib/process-message-rate-limit.js (19L); all files ≤200L; server.js reduced by ~660L and imports/wires all factories after broadcastSync is created
 - 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

package/lib/message-queue.js

@@ -0,0 +1,62 @@
+export function createMessageQueue({ queries, activeExecutions, messageQueues, broadcastSync, execMachine, cleanupExecution, debugLog, getProcessMessageWithStreaming }) {
+  function scheduleRetry(conversationId, messageId, content, agentId, model, subAgent) {
+    debugLog(`[rate-limit] scheduleRetry called for conv ${conversationId}, messageId=${messageId}`);
+    if (!content) {
+      queries.getConversation(conversationId);
+      const lastMsg = queries.getLastUserMessage(conversationId);
+      content = lastMsg?.content || 'continue';
+      debugLog(`[rate-limit] Recovered content from last message: ${content?.substring?.(0, 50)}...`);
+    }
+    const newSession = queries.createSession(conversationId);
+    queries.createEvent('session.created', { messageId, sessionId: newSession.id, retryReason: 'rate_limit' }, conversationId, newSession.id);
+    debugLog(`[rate-limit] Broadcasting streaming_start for retry session ${newSession.id}`);
+    broadcastSync({ type: 'streaming_start', sessionId: newSession.id, conversationId, messageId, agentId, queueLength: messageQueues.get(conversationId)?.length || 0, timestamp: Date.now() });
+    const startTime = Date.now();
+    activeExecutions.set(conversationId, { pid: null, startTime, sessionId: newSession.id, lastActivity: startTime });
+    debugLog(`[rate-limit] Calling processMessageWithStreaming for retry`);
+    getProcessMessageWithStreaming()(conversationId, messageId, newSession.id, content, agentId, model, subAgent)
+      .catch(err => {
+        debugLog(`[rate-limit] Retry failed: ${err.message}`);
+        console.error(`[rate-limit] Retry error for conv ${conversationId}:`, err);
+        cleanupExecution(conversationId);
+        broadcastSync({ type: 'streaming_error', sessionId: newSession.id, conversationId, error: `Rate limit retry failed: ${err.message}`, recoverable: false, timestamp: Date.now() });
+      });
+  }
+
+  function drainMessageQueue(conversationId) {
+    const machineQueue = execMachine.getQueue(conversationId);
+    const mapQueue = messageQueues.get(conversationId);
+    if (machineQueue.length === 0 && (!mapQueue || mapQueue.length === 0)) return;
+    let next;
+    if (machineQueue.length > 0) {
+      execMachine.send(conversationId, { type: 'COMPLETE' });
+      const ctx = execMachine.getContext(conversationId);
+      next = ctx?.nextItem;
+      if (mapQueue && mapQueue.length > 0) mapQueue.shift();
+      if (mapQueue && mapQueue.length === 0) messageQueues.delete(conversationId);
+    } else {
+      next = mapQueue.shift();
+      if (mapQueue.length === 0) messageQueues.delete(conversationId);
+    }
+    if (!next) return;
+    debugLog(`[queue] Draining next message for ${conversationId}, messageId=${next.messageId}`);
+    const remainingQueueLength = execMachine.getQueue(conversationId).length || messageQueues.get(conversationId)?.length || 0;
+    broadcastSync({ type: 'queue_item_dequeued', conversationId, messageId: next.messageId, queueLength: remainingQueueLength, timestamp: Date.now() });
+    const session = queries.createSession(conversationId);
+    queries.createEvent('session.created', { messageId: next.messageId, sessionId: session.id }, conversationId, session.id);
+    broadcastSync({ type: 'streaming_start', sessionId: session.id, conversationId, messageId: next.messageId, agentId: next.agentId, queueLength: remainingQueueLength, timestamp: Date.now() });
+    broadcastSync({ type: 'queue_status', conversationId, queueLength: remainingQueueLength, timestamp: Date.now() });
+    const startTime = Date.now();
+    execMachine.send(conversationId, { type: 'START', sessionId: session.id });
+    activeExecutions.set(conversationId, { pid: null, startTime, sessionId: session.id, lastActivity: startTime });
+    getProcessMessageWithStreaming()(conversationId, next.messageId, session.id, next.content, next.agentId, next.model, next.subAgent)
+      .catch(err => {
+        debugLog(`[queue] Error processing queued message: ${err.message}`);
+        cleanupExecution(conversationId);
+        broadcastSync({ type: 'streaming_error', sessionId: session.id, conversationId, error: `Queue processing failed: ${err.message}`, recoverable: true, timestamp: Date.now() });
+        setTimeout(() => drainMessageQueue(conversationId), 100);
+      });
+  }
+
+  return { scheduleRetry, drainMessageQueue };
+}

package/lib/process-message-rate-limit.js

@@ -0,0 +1,18 @@
+/**
+ * Parse the rate-limit reset time from a text message.
+ * Returns seconds until reset (minimum 60, default 300).
+ */
+export 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;
+  let hours = parseInt(match[1], 10);
+  const minutes = match[2] ? parseInt(match[2], 10) : 0;
+  const period = match[3]?.toLowerCase();
+  if (period === 'pm' && hours !== 12) hours += 12;
+  if (period === 'am' && hours === 12) hours = 0;
+  const now = new Date();
+  const resetTime = new Date(now);
+  resetTime.setUTCHours(hours, minutes, 0, 0);
+  if (resetTime <= now) resetTime.setUTCDate(resetTime.getUTCDate() + 1);
+  return Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
+}

package/lib/process-message.js

@@ -0,0 +1,126 @@
+export function createProcessMessage({ queries, activeExecutions, rateLimitState, execMachine, broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager, discoveredAgents, ownedSessionIds, STARTUP_CWD, buildSystemPrompt, parseRateLimitResetTime, eagerTTS, touchACP, createChunkBatcher, debugLog, logError, scheduleRetry, drainMessageQueue, createEventHandler }) {
+  async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
+    const startTime = Date.now();
+    touchACP(agentId);
+    const conv = queries.getConversation(conversationId);
+    if (!conv) {
+      console.error(`[stream] Conversation ${conversationId} not found, aborting`);
+      queries.updateSession(sessionId, { status: 'error', error: 'Conversation not found' });
+      queries.setIsStreaming(conversationId, false);
+      return;
+    }
+    if (activeExecutions.has(conversationId)) {
+      const existing = activeExecutions.get(conversationId);
+      if (existing.sessionId !== sessionId) {
+        debugLog(`[stream] Conversation ${conversationId} already has active execution (different session), aborting duplicate`);
+        return;
+      }
+    }
+    if (rateLimitState.has(conversationId)) {
+      const rlState = rateLimitState.get(conversationId);
+      if (rlState.retryAt > Date.now()) {
+        debugLog(`[stream] Conversation ${conversationId} is in rate limit cooldown, aborting`);
+        return;
+      }
+    }
+    activeExecutions.set(conversationId, { pid: null, startTime, sessionId, lastActivity: startTime });
+    execMachine.send(conversationId, { type: 'START', sessionId });
+    queries.setIsStreaming(conversationId, true);
+    queries.updateSession(sessionId, { status: 'active' });
+    const batcher = createChunkBatcher(queries, debugLog);
+    const cwd = conv?.workingDirectory || STARTUP_CWD;
+    const allBlocksRef = { val: [] };
+    const currentSequenceRef = { val: queries.getMaxSequence(sessionId) ?? -1 };
+    const batcherRef = { batcher, eventCount: 0, resumeSessionId: conv?.claudeSessionId || null };
+    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime });
+    try {
+      debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
+      let resolvedAgentId = agentId || 'claude-code';
+      const wrapperAgent = discoveredAgents.find(a => a.id === resolvedAgentId && a.protocol === 'cli-wrapper' && a.acpId);
+      if (wrapperAgent) resolvedAgentId = wrapperAgent.acpId;
+      const resolvedModel = model || conv?.model || null;
+      const resolvedSubAgent = subAgent || conv?.subAgent || null;
+      const config = {
+        verbose: true, outputFormat: 'stream-json', timeout: 1800000, print: true,
+        resumeSessionId: batcherRef.resumeSessionId,
+        systemPrompt: buildSystemPrompt(agentId, resolvedModel, resolvedSubAgent),
+        model: resolvedModel || undefined, subAgent: resolvedSubAgent || undefined, onEvent,
+        onPid: (pid) => { const e = activeExecutions.get(conversationId); if (e) e.pid = pid; execMachine.send(conversationId, { type: 'SET_PID', pid }); },
+        onProcess: (proc) => { const e = activeExecutions.get(conversationId); if (e) e.proc = proc; execMachine.send(conversationId, { type: 'SET_PROC', proc }); }
+      };
+      const { outputs, sessionId: claudeSessionId } = await runClaudeWithStreaming(content, cwd, resolvedAgentId, config);
+      if (rateLimitState.get(conversationId)?.isStreamDetected) {
+        debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping success handler`);
+        return;
+      }
+      activeExecutions.delete(conversationId);
+      execMachine.send(conversationId, { type: 'COMPLETE' });
+      batcher.drain();
+      if (claudeSessionId) ownedSessionIds.delete(claudeSessionId);
+      debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
+      queries.updateSession(sessionId, { status: 'complete', response: JSON.stringify({ outputs, eventCount: batcherRef.eventCount }), completed_at: Date.now() });
+      broadcastSync({ type: 'streaming_complete', sessionId, conversationId, agentId, eventCount: batcherRef.eventCount, seq: currentSequenceRef.val, timestamp: Date.now() });
+      debugLog(`[stream] Completed: ${outputs.length} outputs, ${batcherRef.eventCount} events`);
+    } catch (error) {
+      const elapsed = Date.now() - startTime;
+      debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
+      const conv2 = queries.getConversation(conversationId);
+      if (conv2?.claudeSessionId) ownedSessionIds.delete(conv2.claudeSessionId);
+      if (rateLimitState.get(conversationId)?.isStreamDetected) {
+        debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping catch handler`);
+        return;
+      }
+      const isAuthError = error.authError || error.nonRetryable || /401|unauthorized|invalid.*auth|invalid.*token|auth.*failed|permission denied|access denied/i.test(error.message);
+      const isRateLimit = error.rateLimited || /rate.?limit|429|too many requests|overloaded|throttl/i.test(error.message);
+      queries.updateSession(sessionId, { status: 'error', error: error.message, completed_at: Date.now() });
+      if (isAuthError) {
+        debugLog(`[auth-error] Auth error for conv ${conversationId}: ${error.message}`);
+        broadcastSync({ type: 'streaming_error', sessionId, conversationId, error: `Authentication failed: ${error.message}. Please check your API credentials.`, recoverable: false, isAuthError: true, timestamp: Date.now() });
+        const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Authentication failed. ${error.message}. Please update your credentials and try again.`);
+        broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
+        queries.setIsStreaming(conversationId, false);
+        batcher.drain();
+        activeExecutions.delete(conversationId);
+        return;
+      }
+      if (isRateLimit) {
+        const existingState = rateLimitState.get(conversationId) || {};
+        const retryCount = (existingState.retryCount || 0) + 1;
+        const maxRateLimitRetries = 3;
+        if (retryCount > maxRateLimitRetries) {
+          broadcastSync({ type: 'streaming_error', sessionId, conversationId, error: `Rate limit exceeded after ${retryCount} attempts. Please try again later.`, recoverable: false, timestamp: Date.now() });
+          const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${retryCount} attempts. Please try again later.`);
+          broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
+          queries.setIsStreaming(conversationId, false);
+          return;
+        }
+        const cooldownMs = (error.retryAfterSec || 60) * 1000;
+        const retryAt = Date.now() + cooldownMs;
+        rateLimitState.set(conversationId, { retryAt, cooldownMs, retryCount });
+        broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: cooldownMs, retryAt, retryCount, timestamp: Date.now() });
+        batcher.drain();
+        debugLog(`[rate-limit] Scheduling retry for conv ${conversationId} in ${cooldownMs}ms (attempt ${retryCount + 1})`);
+        setTimeout(() => {
+          debugLog(`[rate-limit] Timeout fired for conv ${conversationId}, calling scheduleRetry`);
+          rateLimitState.delete(conversationId);
+          broadcastSync({ type: 'rate_limit_clear', conversationId, timestamp: Date.now() });
+          scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
+        }, cooldownMs);
+        return;
+      }
+      const isSessionConflict = error.exitCode === null && batcherRef.eventCount === 0;
+      broadcastSync({ type: 'streaming_error', sessionId, conversationId, error: error.message, isPrematureEnd: error.isPrematureEnd || false, exitCode: error.exitCode, stderrText: error.stderrText, recoverable: elapsed < 60000, isSessionConflict, timestamp: Date.now() });
+      if (!isSessionConflict) {
+        const errMsg = queries.createMessage(conversationId, 'assistant', `Error: ${error.message}`);
+        broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
+      }
+    } finally {
+      batcher.drain();
+      if (!rateLimitState.has(conversationId)) {
+        cleanupExecution(conversationId);
+        drainMessageQueue(conversationId);
+      }
+    }
+  }
+  return { processMessageWithStreaming };
+}

package/lib/stream-event-handler.js

@@ -0,0 +1,115 @@
+export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
+  return function onEvent(parsed) {
+    batcherRef.eventCount++;
+    const entry = activeExecutions.get(conversationId);
+    if (entry) entry.lastActivity = Date.now();
+    if (parsed.session_id) {
+      ownedSessionIds.add(parsed.session_id);
+      if (!batcherRef.resumeSessionId || batcherRef.resumeSessionId !== parsed.session_id) {
+        batcherRef.resumeSessionId = parsed.session_id;
+        queries.setClaudeSessionId(conversationId, parsed.session_id, sessionId);
+      }
+    }
+    debugLog(`[stream] Event ${batcherRef.eventCount}: type=${parsed.type}`);
+
+    if (parsed.type === 'system') {
+      if (parsed.subtype === 'task_notification') return;
+      if (!parsed.model && !parsed.cwd && !parsed.tools) return;
+      const block = { type: 'system', subtype: parsed.subtype, model: parsed.model, cwd: parsed.cwd, tools: parsed.tools, session_id: parsed.session_id };
+      currentSequenceRef.val++;
+      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'system', block);
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'system', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'assistant' && parsed.message?.content) {
+      for (const block of parsed.message.content) {
+        allBlocksRef.val.push(block);
+        currentSequenceRef.val++;
+        batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, block.type || 'assistant', block);
+        broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'assistant', blockIndex: allBlocksRef.val.length - 1, seq: currentSequenceRef.val, timestamp: Date.now() });
+        if (block.type === 'text' && block.text) {
+          const rateLimitMatch = block.text.match(/you'?ve hit your limit|rate limit exceeded/i);
+          if (rateLimitMatch) {
+            debugLog(`[rate-limit] Detected rate limit message in stream for conv ${conversationId}`);
+            const retryAfterSec = parseRateLimitResetTime(block.text);
+            const entry2 = activeExecutions.get(conversationId);
+            if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (e) {} }
+            const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
+            if (existingCount >= 3) {
+              batcherRef.batcher.drain();
+              activeExecutions.delete(conversationId);
+              queries.setIsStreaming(conversationId, false);
+              const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount + 1} attempts. Please try again later.`);
+              broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
+              broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+              return;
+            }
+            rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount + 1, isStreamDetected: true });
+            broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: 1, timestamp: Date.now() });
+            batcherRef.batcher.drain();
+            activeExecutions.delete(conversationId);
+            queries.setIsStreaming(conversationId, false);
+            setTimeout(() => {
+              rateLimitState.delete(conversationId);
+              broadcastSync({ type: 'rate_limit_clear', conversationId, timestamp: Date.now() });
+              scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
+            }, retryAfterSec * 1000);
+            return;
+          }
+          eagerTTS(block.text, conversationId, sessionId);
+        }
+      }
+    } else if (parsed.type === 'user' && parsed.message?.content) {
+      for (const block of parsed.message.content) {
+        if (block.type === 'tool_result') {
+          const toolResultBlock = { type: 'tool_result', tool_use_id: block.tool_use_id, content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content), is_error: block.is_error || false };
+          currentSequenceRef.val++;
+          batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'tool_result', toolResultBlock);
+          broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: toolResultBlock, blockRole: 'tool_result', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
+        }
+      }
+    } else if (parsed.type === 'result') {
+      const resultBlock = { type: 'result', subtype: parsed.subtype, duration_ms: parsed.duration_ms, total_cost_usd: parsed.total_cost_usd, num_turns: parsed.num_turns, is_error: parsed.is_error || false, result: parsed.result };
+      currentSequenceRef.val++;
+      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'result', resultBlock);
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: resultBlock, blockRole: 'result', blockIndex: allBlocksRef.val.length, isResult: true, seq: currentSequenceRef.val, timestamp: Date.now() });
+      if (parsed.result) {
+        const resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
+        const rlMatch = resultText.match(/you'?ve hit your limit|rate limit exceeded/i);
+        if (rlMatch) {
+          debugLog(`[rate-limit] Detected rate limit in result for conv ${conversationId}`);
+          const retryAfterSec = parseRateLimitResetTime(resultText);
+          const entry3 = activeExecutions.get(conversationId);
+          if (entry3 && entry3.pid) { try { process.kill(entry3.pid); } catch (e) {} }
+          const existingCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
+          if (existingCount2 >= 3) {
+            batcherRef.batcher.drain();
+            activeExecutions.delete(conversationId);
+            queries.setIsStreaming(conversationId, false);
+            const errMsg2 = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount2 + 1} attempts. Please try again later.`);
+            broadcastSync({ type: 'message_created', conversationId, message: errMsg2, timestamp: Date.now() });
+            broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
+            return;
+          }
+          rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount2 + 1, isStreamDetected: true });
+          broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: existingCount2 + 1, timestamp: Date.now() });
+          batcherRef.batcher.drain();
+          activeExecutions.delete(conversationId);
+          queries.setIsStreaming(conversationId, false);
+          setTimeout(() => {
+            rateLimitState.delete(conversationId);
+            broadcastSync({ type: 'rate_limit_clear', conversationId, timestamp: Date.now() });
+            scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
+          }, retryAfterSec * 1000);
+          return;
+        }
+        if (resultText) eagerTTS(resultText, conversationId, sessionId);
+      }
+      if (parsed.result && allBlocksRef.val.length === 0) allBlocksRef.val.push({ type: 'text', text: String(parsed.result) });
+    } else if (parsed.type === 'tool_status') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'tool_status', tool_use_id: parsed.tool_use_id, status: parsed.status }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'usage') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'usage', usage: parsed.usage }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    } else if (parsed.type === 'plan') {
+      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: { type: 'plan', entries: parsed.entries }, seq: currentSequenceRef.val, timestamp: Date.now() });
+    }
+  };
+}

package/package.json

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

package/scripts/patch-fsbrowse.js

@@ -197,4 +197,4 @@ if (fs.existsSync(fsbrowseAppJSPath)) {
   } catch (err) {
     console.warn('[PATCH] Could not patch fsbrowse app.js:', err.message);
   }
-}
+}

package/server.js

@@ -53,6 +53,10 @@ 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';
+import { parseRateLimitResetTime } from './lib/process-message-rate-limit.js';
+import { createEventHandler } from './lib/stream-event-handler.js';
+import { createMessageQueue } from './lib/message-queue.js';
+import { createProcessMessage } from './lib/process-message.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -1659,680 +1663,6 @@ function serveFile(filePath, res, req) { return _serveFile(filePath, res, req, _
 
 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;
-  let hours = parseInt(match[1], 10);
-  const minutes = match[2] ? parseInt(match[2], 10) : 0;
-  const period = match[3]?.toLowerCase();
-  if (period === 'pm' && hours !== 12) hours += 12;
-  if (period === 'am' && hours === 12) hours = 0;
-  const now = new Date();
-  const resetTime = new Date(now);
-  resetTime.setUTCHours(hours, minutes, 0, 0);
-  if (resetTime <= now) resetTime.setUTCDate(resetTime.getUTCDate() + 1);
-  return Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
-}
-
-async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
-  const startTime = Date.now();
-  touchACP(agentId);
-  
-  const conv = queries.getConversation(conversationId);
-  if (!conv) {
-    console.error(`[stream] Conversation ${conversationId} not found, aborting`);
-    queries.updateSession(sessionId, { status: 'error', error: 'Conversation not found' });
-    queries.setIsStreaming(conversationId, false);
-    return;
-  }
-  
-  if (activeExecutions.has(conversationId)) {
-    const existing = activeExecutions.get(conversationId);
-    if (existing.sessionId !== sessionId) {
-      debugLog(`[stream] Conversation ${conversationId} already has active execution (different session), aborting duplicate`);
-      return;
-    }
-  }
-  
-  if (rateLimitState.has(conversationId)) {
-    const rlState = rateLimitState.get(conversationId);
-    if (rlState.retryAt > Date.now()) {
-      debugLog(`[stream] Conversation ${conversationId} is in rate limit cooldown, aborting`);
-      return;
-    }
-  }
-  
-  activeExecutions.set(conversationId, { pid: null, startTime, sessionId, lastActivity: startTime });
-  execMachine.send(conversationId, { type: 'START', sessionId });
-  queries.setIsStreaming(conversationId, true);
-  queries.updateSession(sessionId, { status: 'active' });
-  const batcher = createChunkBatcher(queries, debugLog);
-
-  try {
-    debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
-
-    const cwd = conv?.workingDirectory || STARTUP_CWD;
-    let resumeSessionId = conv?.claudeSessionId || null;
-
-    let allBlocks = [];
-    let eventCount = 0;
-    let currentSequence = queries.getMaxSequence(sessionId) ?? -1;
-
-    const onEvent = (parsed) => {
-      eventCount++;
-      const entry = activeExecutions.get(conversationId);
-      if (entry) entry.lastActivity = Date.now();
-      if (parsed.session_id) {
-        ownedSessionIds.add(parsed.session_id);
-        if (!resumeSessionId || resumeSessionId !== parsed.session_id) {
-          resumeSessionId = parsed.session_id;
-          queries.setClaudeSessionId(conversationId, parsed.session_id, sessionId);
-        }
-      }
-      debugLog(`[stream] Event ${eventCount}: type=${parsed.type}`);
-
-      if (parsed.type === 'system') {
-        if (parsed.subtype === 'task_notification') return;
-        if (!parsed.model && !parsed.cwd && !parsed.tools) return;
-
-        const systemBlock = {
-          type: 'system',
-          subtype: parsed.subtype,
-          model: parsed.model,
-          cwd: parsed.cwd,
-          tools: parsed.tools,
-          session_id: parsed.session_id
-        };
-
-        currentSequence++;
-        batcher.add(sessionId, conversationId, currentSequence, 'system', systemBlock);
-
-        broadcastSync({
-          type: 'streaming_progress',
-          sessionId,
-          conversationId,
-          block: systemBlock,
-          blockRole: 'system',
-          blockIndex: allBlocks.length,
-          seq: currentSequence,
-          timestamp: Date.now()
-        });
-      } else if (parsed.type === 'assistant' && parsed.message?.content) {
-        for (const block of parsed.message.content) {
-          allBlocks.push(block);
-
-          currentSequence++;
-          batcher.add(sessionId, conversationId, currentSequence, block.type || 'assistant', block);
-
-          broadcastSync({
-            type: 'streaming_progress',
-            sessionId,
-            conversationId,
-            block,
-            blockRole: 'assistant',
-            blockIndex: allBlocks.length - 1,
-            seq: currentSequence,
-            timestamp: Date.now()
-          });
-
-          if (block.type === 'text' && block.text) {
-            // Check for rate limit message in text content
-            const rateLimitTextMatch = block.text.match(/you'?ve hit your limit|rate limit exceeded/i);
-            if (rateLimitTextMatch) {
-              debugLog(`[rate-limit] Detected rate limit message in stream for conv ${conversationId}`);
-              
-              const retryAfterSec = parseRateLimitResetTime(block.text);
-              debugLog(`[rate-limit] Parsed reset time, retry in ${retryAfterSec}s`);
-              
-              // Kill the running process
-              const entry = activeExecutions.get(conversationId);
-              if (entry && entry.pid) {
-                try {
-                  process.kill(entry.pid);
-                  debugLog(`[rate-limit] Killed process ${entry.pid} for conv ${conversationId}`);
-                } catch (e) {
-                  debugLog(`[rate-limit] Failed to kill process: ${e.message}`);
-                }
-              }
-              
-              // Set flag to stop processing and trigger retry
-              const existingRetryCount = rateLimitState.get(conversationId)?.retryCount || 0;
-              if (existingRetryCount >= 3) {
-                debugLog(`[rate-limit] Conv ${conversationId} stream rate limit hit ${existingRetryCount + 1} times, giving up`);
-                batcher.drain();
-                activeExecutions.delete(conversationId);
-                queries.setIsStreaming(conversationId, false);
-                const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingRetryCount + 1} attempts. Please try again later.`);
-                broadcastSync({ type: 'message_created', conversationId, message: errorMessage, timestamp: Date.now() });
-                broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
-                return;
-              }
-              rateLimitState.set(conversationId, {
-                retryAt: Date.now() + (retryAfterSec * 1000),
-                cooldownMs: retryAfterSec * 1000,
-                retryCount: existingRetryCount + 1,
-                isStreamDetected: true
-              });
-              
-              // Broadcast rate limit event
-              broadcastSync({
-                type: 'rate_limit_hit',
-                sessionId,
-                conversationId,
-                retryAfterMs: retryAfterSec * 1000,
-                retryAt: Date.now() + (retryAfterSec * 1000),
-                retryCount: 1,
-                timestamp: Date.now()
-              });
-              
-              batcher.drain();
-              activeExecutions.delete(conversationId);
-              queries.setIsStreaming(conversationId, false);
-              
-              // Schedule retry
-              setTimeout(() => {
-                rateLimitState.delete(conversationId);
-                broadcastSync({
-                  type: 'rate_limit_clear',
-                  conversationId,
-                  timestamp: Date.now()
-                });
-                scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
-              }, retryAfterSec * 1000);
-              
-              return; // Stop processing events
-            }
-            
-            eagerTTS(block.text, conversationId, sessionId);
-          }
-        }
-      } else if (parsed.type === 'user' && parsed.message?.content) {
-        for (const block of parsed.message.content) {
-          if (block.type === 'tool_result') {
-            const toolResultBlock = {
-              type: 'tool_result',
-              tool_use_id: block.tool_use_id,
-              content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content),
-              is_error: block.is_error || false
-            };
-
-            currentSequence++;
-            batcher.add(sessionId, conversationId, currentSequence, 'tool_result', toolResultBlock);
-
-            broadcastSync({
-              type: 'streaming_progress',
-              sessionId,
-              conversationId,
-              block: toolResultBlock,
-              blockRole: 'tool_result',
-              blockIndex: allBlocks.length,
-              seq: currentSequence,
-              timestamp: Date.now()
-            });
-          }
-        }
-      } else if (parsed.type === 'result') {
-        const resultBlock = {
-          type: 'result',
-          subtype: parsed.subtype,
-          duration_ms: parsed.duration_ms,
-          total_cost_usd: parsed.total_cost_usd,
-          num_turns: parsed.num_turns,
-          is_error: parsed.is_error || false,
-          result: parsed.result
-        };
-
-        currentSequence++;
-        batcher.add(sessionId, conversationId, currentSequence, 'result', resultBlock);
-
-        broadcastSync({
-          type: 'streaming_progress',
-          sessionId,
-          conversationId,
-          block: resultBlock,
-          blockRole: 'result',
-          blockIndex: allBlocks.length,
-          isResult: true,
-          seq: currentSequence,
-          timestamp: Date.now()
-        });
-
-        if (parsed.result) {
-          const resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
-          
-          // Check for rate limit message in result
-          const rateLimitResultMatch = resultText.match(/you'?ve hit your limit|rate limit exceeded/i);
-          if (rateLimitResultMatch) {
-            debugLog(`[rate-limit] Detected rate limit in result for conv ${conversationId}`);
-            
-            const retryAfterSec = parseRateLimitResetTime(resultText);
-            
-            const entry = activeExecutions.get(conversationId);
-            if (entry && entry.pid) {
-              try {
-                process.kill(entry.pid);
-              } catch (e) {}
-            }
-            
-            const existingRetryCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
-            if (existingRetryCount2 >= 3) {
-              debugLog(`[rate-limit] Conv ${conversationId} result rate limit hit ${existingRetryCount2 + 1} times, giving up`);
-              batcher.drain();
-              activeExecutions.delete(conversationId);
-              queries.setIsStreaming(conversationId, false);
-              const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingRetryCount2 + 1} attempts. Please try again later.`);
-              broadcastSync({ type: 'message_created', conversationId, message: errorMessage, timestamp: Date.now() });
-              broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
-              return;
-            }
-            rateLimitState.set(conversationId, {
-              retryAt: Date.now() + (retryAfterSec * 1000),
-              cooldownMs: retryAfterSec * 1000,
-              retryCount: existingRetryCount2 + 1,
-              isStreamDetected: true
-            });
-
-            broadcastSync({
-              type: 'rate_limit_hit',
-              sessionId,
-              conversationId,
-              retryAfterMs: retryAfterSec * 1000,
-              retryAt: Date.now() + (retryAfterSec * 1000),
-              retryCount: existingRetryCount2 + 1,
-              timestamp: Date.now()
-            });
-
-            batcher.drain();
-            activeExecutions.delete(conversationId);
-            queries.setIsStreaming(conversationId, false);
-
-            setTimeout(() => {
-              rateLimitState.delete(conversationId);
-              broadcastSync({
-                type: 'rate_limit_clear',
-                conversationId,
-                timestamp: Date.now()
-              });
-              scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
-            }, retryAfterSec * 1000);
-
-            return;
-          }
-          
-          if (resultText) eagerTTS(resultText, conversationId, sessionId);
-        }
-
-        if (parsed.result && allBlocks.length === 0) {
-          allBlocks.push({ type: 'text', text: String(parsed.result) });
-        }
-      } else if (parsed.type === 'tool_status') {
-        // Handle ACP tool status updates (in_progress, pending)
-        broadcastSync({
-          type: 'streaming_progress',
-          sessionId,
-          conversationId,
-          block: {
-            type: 'tool_status',
-            tool_use_id: parsed.tool_use_id,
-            status: parsed.status
-          },
-          seq: currentSequence,
-          timestamp: Date.now()
-        });
-      } else if (parsed.type === 'usage') {
-        // Handle ACP usage updates
-        broadcastSync({
-          type: 'streaming_progress',
-          sessionId,
-          conversationId,
-          block: {
-            type: 'usage',
-            usage: parsed.usage
-          },
-          seq: currentSequence,
-          timestamp: Date.now()
-        });
-      } else if (parsed.type === 'plan') {
-        // Handle ACP plan updates
-        broadcastSync({
-          type: 'streaming_progress',
-          sessionId,
-          conversationId,
-          block: {
-            type: 'plan',
-            entries: parsed.entries
-          },
-          seq: currentSequence,
-          timestamp: Date.now()
-        });
-      }
-    };
-
-    const resolvedModel = model || conv?.model || null;
-    const resolvedSubAgent = subAgent || conv?.subAgent || null;
-    const unifiedSystemPrompt = buildSystemPrompt(agentId, resolvedModel, resolvedSubAgent);
-    const config = {
-      verbose: true,
-      outputFormat: 'stream-json',
-      timeout: 1800000,
-      print: true,
-      resumeSessionId,
-      systemPrompt: unifiedSystemPrompt,
-      model: resolvedModel || undefined,
-      subAgent: resolvedSubAgent || undefined,
-      onEvent,
-      onPid: (pid) => {
-        const entry = activeExecutions.get(conversationId);
-        if (entry) entry.pid = pid;
-        execMachine.send(conversationId, { type: 'SET_PID', pid });
-      },
-      onProcess: (proc) => {
-        const entry = activeExecutions.get(conversationId);
-        if (entry) entry.proc = proc;
-        execMachine.send(conversationId, { type: 'SET_PROC', proc });
-      }
-    };
-
-    // Resolve cli-wrapper agent IDs (e.g. cli-kilo → kilo) to their underlying registered agent
-    let resolvedAgentId = agentId || 'claude-code';
-    const wrapperAgent = discoveredAgents.find(a => a.id === resolvedAgentId && a.protocol === 'cli-wrapper' && a.acpId);
-    if (wrapperAgent) resolvedAgentId = wrapperAgent.acpId;
-
-    const { outputs, sessionId: claudeSessionId } = await runClaudeWithStreaming(content, cwd, resolvedAgentId, config);
-
-    // Check if rate limit was already handled in stream detection
-    if (rateLimitState.get(conversationId)?.isStreamDetected) {
-      debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping success handler`);
-      return;
-    }
-
-    activeExecutions.delete(conversationId);
-    execMachine.send(conversationId, { type: 'COMPLETE' });
-    batcher.drain();
-    if (claudeSessionId) ownedSessionIds.delete(claudeSessionId);
-    debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
-
-    debugLog(`[stream] Keeping claudeSessionId=${claudeSessionId} for session continuity`);
-
-    // Mark session as complete
-    queries.updateSession(sessionId, {
-      status: 'complete',
-      response: JSON.stringify({ outputs, eventCount }),
-      completed_at: Date.now()
-    });
-
-    broadcastSync({
-      type: 'streaming_complete',
-      sessionId,
-      conversationId,
-      agentId,
-      eventCount,
-      seq: currentSequence,
-      timestamp: Date.now()
-    });
-
-    debugLog(`[stream] Completed: ${outputs.length} outputs, ${eventCount} events`);
-  } catch (error) {
-    const elapsed = Date.now() - startTime;
-    debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
-    const conv2 = queries.getConversation(conversationId);
-    if (conv2?.claudeSessionId) ownedSessionIds.delete(conv2.claudeSessionId);
-
-    // Check if rate limit was already handled in stream detection
-    const existingState = rateLimitState.get(conversationId);
-    if (existingState?.isStreamDetected) {
-      debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping catch handler`);
-      return;
-    }
-
-    const isAuthError = error.authError || error.nonRetryable ||
-      /401|unauthorized|invalid.*auth|invalid.*token|auth.*failed|permission denied|access denied/i.test(error.message);
-
-    const isRateLimit = error.rateLimited ||
-      /rate.?limit|429|too many requests|overloaded|throttl/i.test(error.message);
-
-    queries.updateSession(sessionId, {
-      status: 'error',
-      error: error.message,
-      completed_at: Date.now()
-    });
-
-    if (isAuthError) {
-      debugLog(`[auth-error] Auth error for conv ${conversationId}: ${error.message}`);
-      broadcastSync({
-        type: 'streaming_error',
-        sessionId,
-        conversationId,
-        error: `Authentication failed: ${error.message}. Please check your API credentials.`,
-        recoverable: false,
-        isAuthError: true,
-        timestamp: Date.now()
-      });
-      const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: Authentication failed. ${error.message}. Please update your credentials and try again.`);
-      broadcastSync({
-        type: 'message_created',
-        conversationId,
-        message: errorMessage,
-        timestamp: Date.now()
-      });
-      queries.setIsStreaming(conversationId, false);
-      batcher.drain();
-      activeExecutions.delete(conversationId);
-      return;
-    }
-
-    if (isRateLimit) {
-      const existingState = rateLimitState.get(conversationId) || {};
-      const retryCount = (existingState.retryCount || 0) + 1;
-      const maxRateLimitRetries = 3;
-
-      if (retryCount > maxRateLimitRetries) {
-        debugLog(`[rate-limit] Conv ${conversationId} hit rate limit ${retryCount} times, giving up`);
-        broadcastSync({
-          type: 'streaming_error',
-          sessionId,
-          conversationId,
-          error: `Rate limit exceeded after ${retryCount} attempts. Please try again later.`,
-          recoverable: false,
-          timestamp: Date.now()
-        });
-        const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${retryCount} attempts. Please try again later.`);
-        broadcastSync({
-          type: 'message_created',
-          conversationId,
-          message: errorMessage,
-          timestamp: Date.now()
-        });
-        queries.setIsStreaming(conversationId, false);
-        return;
-      }
-
-      const cooldownMs = (error.retryAfterSec || 60) * 1000;
-      const retryAt = Date.now() + cooldownMs;
-      rateLimitState.set(conversationId, { retryAt, cooldownMs, retryCount });
-      debugLog(`[rate-limit] Conv ${conversationId} hit rate limit (attempt ${retryCount}/${maxRateLimitRetries}), retry in ${cooldownMs}ms`);
-
-      broadcastSync({
-        type: 'rate_limit_hit',
-        sessionId,
-        conversationId,
-        retryAfterMs: cooldownMs,
-        retryAt,
-        retryCount,
-        timestamp: Date.now()
-      });
-
-      batcher.drain();
-
-      debugLog(`[rate-limit] Scheduling retry for conv ${conversationId} in ${cooldownMs}ms (attempt ${retryCount + 1})`);
-      
-      setTimeout(() => {
-        debugLog(`[rate-limit] Timeout fired for conv ${conversationId}, calling scheduleRetry`);
-        rateLimitState.delete(conversationId);
-        debugLog(`[rate-limit] Conv ${conversationId} cooldown expired, restarting (attempt ${retryCount + 1})`);
-        broadcastSync({
-          type: 'rate_limit_clear',
-          conversationId,
-          timestamp: Date.now()
-        });
-        scheduleRetry(conversationId, messageId, content, agentId, model, subAgent);
-      }, cooldownMs);
-      return;
-    }
-
-    const isSessionConflict = error.exitCode === null && eventCount === 0;
-
-    broadcastSync({
-      type: 'streaming_error',
-      sessionId,
-      conversationId,
-      error: error.message,
-      isPrematureEnd: error.isPrematureEnd || false,
-      exitCode: error.exitCode,
-      stderrText: error.stderrText,
-      recoverable: elapsed < 60000,
-      isSessionConflict,
-      timestamp: Date.now()
-    });
-
-    if (!isSessionConflict) {
-      const errorMessage = queries.createMessage(conversationId, 'assistant', `Error: ${error.message}`);
-      broadcastSync({
-        type: 'message_created',
-        conversationId,
-        message: errorMessage,
-        timestamp: Date.now()
-      });
-    }
-  } finally {
-    batcher.drain();
-    // Use atomic cleanup but only if not in rate limit recovery
-    if (!rateLimitState.has(conversationId)) {
-      cleanupExecution(conversationId);
-      drainMessageQueue(conversationId);
-    }
-  }
-}
-
-function scheduleRetry(conversationId, messageId, content, agentId, model, subAgent) {
-  debugLog(`[rate-limit] scheduleRetry called for conv ${conversationId}, messageId=${messageId}`);
-
-  if (!content) {
-    const conv = queries.getConversation(conversationId);
-    const lastMsg = queries.getLastUserMessage(conversationId);
-    content = lastMsg?.content || 'continue';
-    debugLog(`[rate-limit] Recovered content from last message: ${content?.substring?.(0, 50)}...`);
-  }
-
-  const newSession = queries.createSession(conversationId);
-  queries.createEvent('session.created', { messageId, sessionId: newSession.id, retryReason: 'rate_limit' }, conversationId, newSession.id);
-
-  debugLog(`[rate-limit] Broadcasting streaming_start for retry session ${newSession.id}`);
-  broadcastSync({
-    type: 'streaming_start',
-    sessionId: newSession.id,
-    conversationId,
-    messageId,
-    agentId,
-    queueLength: messageQueues.get(conversationId)?.length || 0,
-    timestamp: Date.now()
-  });
-
-  const startTime = Date.now();
-  activeExecutions.set(conversationId, { pid: null, startTime, sessionId: newSession.id, lastActivity: startTime });
-
-  debugLog(`[rate-limit] Calling processMessageWithStreaming for retry`);
-  processMessageWithStreaming(conversationId, messageId, newSession.id, content, agentId, model, subAgent)
-    .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()
-      });
-    });
-}
-
-function drainMessageQueue(conversationId) {
-  // Machine context queue is authoritative; fall back to legacy Map
-  const machineQueue = execMachine.getQueue(conversationId);
-  const mapQueue = messageQueues.get(conversationId);
-  if (machineQueue.length === 0 && (!mapQueue || mapQueue.length === 0)) return;
-
-  let next;
-  if (machineQueue.length > 0) {
-    // Consume from machine via COMPLETE transition (draining state pops nextItem)
-    execMachine.send(conversationId, { type: 'COMPLETE' });
-    const ctx = execMachine.getContext(conversationId);
-    next = ctx?.nextItem;
-    // Also keep Map in sync
-    if (mapQueue && mapQueue.length > 0) mapQueue.shift();
-    if (mapQueue && mapQueue.length === 0) messageQueues.delete(conversationId);
-  } else {
-    next = mapQueue.shift();
-    if (mapQueue.length === 0) messageQueues.delete(conversationId);
-  }
-
-  if (!next) return;
-
-  debugLog(`[queue] Draining next message for ${conversationId}, messageId=${next.messageId}`);
-
-  const remainingQueueLength = execMachine.getQueue(conversationId).length || messageQueues.get(conversationId)?.length || 0;
-
-  broadcastSync({
-    type: 'queue_item_dequeued',
-    conversationId,
-    messageId: next.messageId,
-    queueLength: remainingQueueLength,
-    timestamp: Date.now()
-  });
-
-  const session = queries.createSession(conversationId);
-  queries.createEvent('session.created', { messageId: next.messageId, sessionId: session.id }, conversationId, session.id);
-
-  broadcastSync({
-    type: 'streaming_start',
-    sessionId: session.id,
-    conversationId,
-    messageId: next.messageId,
-    agentId: next.agentId,
-    queueLength: remainingQueueLength,
-    timestamp: Date.now()
-  });
-
-  broadcastSync({
-    type: 'queue_status',
-    conversationId,
-    queueLength: remainingQueueLength,
-    timestamp: Date.now()
-  });
-
-  const startTime = Date.now();
-  // Machine START event makes machine authoritative for this execution
-  execMachine.send(conversationId, { type: 'START', sessionId: session.id });
-  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}`);
-      cleanupExecution(conversationId);
-      broadcastSync({
-        type: 'streaming_error',
-        sessionId: session.id,
-        conversationId,
-        error: `Queue processing failed: ${err.message}`,
-        recoverable: true,
-        timestamp: Date.now()
-      });
-      setTimeout(() => drainMessageQueue(conversationId), 100);
-    });
-}
 
 
 const wss = new WebSocketServer({
@@ -2425,6 +1755,23 @@ const broadcastSync = createBroadcast({
   getSeq: () => ++broadcastSeq
 });
 
+// Wire up process-message factories now that broadcastSync and all deps are available
+const _mqDeps = {
+  queries, messageQueues, activeExecutions, rateLimitState, execMachine,
+  broadcastSync, cleanupExecution, debugLog,
+  getProcessMessageWithStreaming: () => processMessageWithStreaming
+};
+const { scheduleRetry, drainMessageQueue } = createMessageQueue(_mqDeps);
+
+const { processMessageWithStreaming } = createProcessMessage({
+  queries, activeExecutions, rateLimitState, execMachine,
+  broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager,
+  discoveredAgents, ownedSessionIds, STARTUP_CWD, buildSystemPrompt,
+  parseRateLimitResetTime, eagerTTS, touchACP, createChunkBatcher,
+  debugLog, logError,
+  scheduleRetry, drainMessageQueue, createEventHandler
+});
+
 // WebSocket protocol router
 const wsRouter = new WsRouter();