agentgui 1.0.837 → 1.0.839

package/server.js

@@ -27,6 +27,12 @@ import { register as registerThreadRoutes } from './lib/routes-threads.js';
 import { register as registerDebugRoutes } from './lib/routes-debug.js';
 import { register as registerConvRoutes } from './lib/routes-conversations.js';
 import { register as registerAgentRoutes } from './lib/routes-agents.js';
+import { register as registerMessagesRoutes } from './lib/routes-messages.js';
+import { register as registerSessionsRoutes } from './lib/routes-sessions.js';
+import { register as registerRunsRoutes } from './lib/routes-runs.js';
+import { register as registerScriptsRoutes } from './lib/routes-scripts.js';
+import { register as registerAgentActionsRoutes } from './lib/routes-agent-actions.js';
+import { register as registerAuthConfigRoutes } from './lib/routes-auth-config.js';
 import { startCodexOAuth, exchangeCodexOAuthCode, handleCodexOAuthCallback, getCodexOAuthStatus, getCodexOAuthState, CODEX_HOME, CODEX_AUTH_FILE } from './lib/oauth-codex.js';
 import { WSOptimizer } from './lib/ws-optimizer.js';
 import { WsRouter } from './lib/ws-protocol.js';
@@ -53,6 +59,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) => {
@@ -546,1049 +556,29 @@ const server = http.createServer(async (req, res) => {
     const convHandler = _convRoutes._match(req.method, pathOnly);
     if (convHandler) { await convHandler(req, res); return; }
 
-    const messagesMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/messages$/);
-    if (messagesMatch) {
-      if (req.method === 'GET') {
-        const url = new URL(req.url, 'http://localhost');
-        const limit = Math.min(parseInt(url.searchParams.get('limit') || '50'), 500);
-        const offset = Math.max(parseInt(url.searchParams.get('offset') || '0'), 0);
-        const result = queries.getPaginatedMessages(messagesMatch[1], limit, offset);
-                sendJSON(req, res, 200, result);
-        return;
-      }
-
-      if (req.method === 'POST') {
-        const conversationId = messagesMatch[1];
-        const conv = queries.getConversation(conversationId);
-        if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
-        const body = await parseBody(req);
-        const agentId = body.agentId || conv.agentType || conv.agentId || 'claude-code';
-        const model = body.model || conv.model || null;
-        const subAgent = body.subAgent || conv.subAgent || null;
-        const idempotencyKey = body.idempotencyKey || null;
-        const message = queries.createMessage(conversationId, 'user', body.content, idempotencyKey);
-        queries.createEvent('message.created', { role: 'user', messageId: message.id }, conversationId);
-        broadcastSync({ type: 'message_created', conversationId, message, timestamp: Date.now() });
-
-        if (activeExecutions.has(conversationId)) {
-          if (!messageQueues.has(conversationId)) messageQueues.set(conversationId, []);
-          messageQueues.get(conversationId).push({ content: body.content, agentId, model, messageId: message.id, subAgent });
-          const queueLength = messageQueues.get(conversationId).length;
-          broadcastSync({ type: 'queue_status', conversationId, queueLength, messageId: message.id, timestamp: Date.now() });
-          sendJSON(req, res, 200, { message, queued: true, queuePosition: queueLength, idempotencyKey });
-          return;
-        }
-
-        const session = queries.createSession(conversationId);
-        queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, conversationId, session.id);
-
-        activeExecutions.set(conversationId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
-        queries.setIsStreaming(conversationId, true);
-
-        broadcastSync({
-          type: 'streaming_start',
-          sessionId: session.id,
-          conversationId,
-          messageId: message.id,
-          agentId,
-          timestamp: Date.now()
-        });
-
-        sendJSON(req, res, 201, { message, session, idempotencyKey });
-
-        processMessageWithStreaming(conversationId, message.id, session.id, body.content, agentId, model, subAgent)
-          .catch(err => {
-            console.error(`[messages] Uncaught error for conv ${conversationId}:`, err.message);
-            debugLog(`[messages] Uncaught error: ${err.message}`);
-            logError('processMessageWithStreaming', err, { convId: conversationId });
-          });
-        return;
-      }
-    }
-
-    const streamMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/stream$/);
-    if (streamMatch && req.method === 'POST') {
-      const conversationId = streamMatch[1];
-      const body = await parseBody(req);
-      const conv = queries.getConversation(conversationId);
-      if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
-
-      const prompt = body.content || body.message || '';
-      const agentId = body.agentId || conv.agentType || conv.agentId || 'claude-code';
-      const model = body.model || conv.model || null;
-      const subAgent = body.subAgent || conv.subAgent || null;
-
-      const userMessage = queries.createMessage(conversationId, 'user', prompt);
-      queries.createEvent('message.created', { role: 'user', messageId: userMessage.id }, conversationId);
-
-      broadcastSync({ type: 'message_created', conversationId, message: userMessage, timestamp: Date.now() });
-
-      if (activeExecutions.has(conversationId)) {
-        debugLog(`[stream] Conversation ${conversationId} is busy, queuing message`);
-        if (!messageQueues.has(conversationId)) messageQueues.set(conversationId, []);
-        messageQueues.get(conversationId).push({ content: prompt, agentId, model, messageId: userMessage.id, subAgent });
-
-        const queueLength = messageQueues.get(conversationId).length;
-        broadcastSync({ type: 'queue_status', conversationId, queueLength, messageId: userMessage.id, timestamp: Date.now() });
-
-                sendJSON(req, res, 200, { message: userMessage, queued: true, queuePosition: queueLength });
-        return;
-      }
-
-      const session = queries.createSession(conversationId);
-      queries.createEvent('session.created', { messageId: userMessage.id, sessionId: session.id }, conversationId, session.id);
-
-      activeExecutions.set(conversationId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
-      queries.setIsStreaming(conversationId, true);
-
-      broadcastSync({
-        type: 'streaming_start',
-        sessionId: session.id,
-        conversationId,
-        messageId: userMessage.id,
-        agentId,
-        timestamp: Date.now()
-      });
-
-      sendJSON(req, res, 200, { message: userMessage, session, streamId: session.id });
-
-      processMessageWithStreaming(conversationId, userMessage.id, session.id, prompt, agentId, model, subAgent)
-        .catch(err => debugLog(`[stream] Uncaught error: ${err.stack || err.message}`));
-      return;
-    }
-
-    const queueMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/queue$/);
-    if (queueMatch && req.method === 'GET') {
-      const conversationId = queueMatch[1];
-      const conv = queries.getConversation(conversationId);
-      if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
-      const queue = messageQueues.get(conversationId) || [];
-      sendJSON(req, res, 200, { queue });
-      return;
-    }
-
-    const queueItemMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/queue\/([^/]+)$/);
-    if (queueItemMatch && req.method === 'DELETE') {
-      const conversationId = queueItemMatch[1];
-      const messageId = queueItemMatch[2];
-      const queue = messageQueues.get(conversationId);
-      if (!queue) { sendJSON(req, res, 404, { error: 'Queue not found' }); return; }
-      const index = queue.findIndex(q => q.messageId === messageId);
-      if (index === -1) { sendJSON(req, res, 404, { error: 'Queued message not found' }); return; }
-      queue.splice(index, 1);
-      if (queue.length === 0) messageQueues.delete(conversationId);
-      broadcastSync({ type: 'queue_status', conversationId, queueLength: queue?.length || 0, timestamp: Date.now() });
-      sendJSON(req, res, 200, { deleted: true });
-      return;
-    }
-
-    if (queueItemMatch && req.method === 'PATCH') {
-      const conversationId = queueItemMatch[1];
-      const messageId = queueItemMatch[2];
-      const body = await parseBody(req);
-      const queue = messageQueues.get(conversationId);
-      if (!queue) { sendJSON(req, res, 404, { error: 'Queue not found' }); return; }
-      const item = queue.find(q => q.messageId === messageId);
-      if (!item) { sendJSON(req, res, 404, { error: 'Queued message not found' }); return; }
-      if (body.content !== undefined) item.content = body.content;
-      if (body.agentId !== undefined) item.agentId = body.agentId;
-      broadcastSync({ type: 'queue_updated', conversationId, messageId, content: item.content, agentId: item.agentId, timestamp: Date.now() });
-      sendJSON(req, res, 200, { updated: true, item });
-      return;
-    }
-
-    const messageMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/messages\/([^/]+)$/);
-    if (messageMatch && req.method === 'GET') {
-      const msg = queries.getMessage(messageMatch[2]);
-      if (!msg || msg.conversationId !== messageMatch[1]) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-            sendJSON(req, res, 200, { message: msg });
-      return;
-    }
-
-    const sessionMatch = pathOnly.match(/^\/api\/sessions\/([^/]+)$/);
-    if (sessionMatch && req.method === 'GET') {
-      const sess = queries.getSession(sessionMatch[1]);
-      if (!sess) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-      const events = queries.getSessionEvents(sessionMatch[1]);
-            sendJSON(req, res, 200, { session: sess, events });
-      return;
-    }
-
-    const fullLoadMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/full$/);
-    if (fullLoadMatch && req.method === 'GET') {
-      const conversationId = fullLoadMatch[1];
-      const conv = queries.getConversation(conversationId);
-      if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-      const latestSession = queries.getLatestSession(conversationId);
-      const isActivelyStreaming = activeExecutions.has(conversationId);
-
-      const url = new URL(req.url, 'http://localhost');
-      const chunkLimit = Math.min(parseInt(url.searchParams.get('chunkLimit') || '500'), 5000);
-      const allChunks = url.searchParams.get('allChunks') === '1';
-
-      const totalChunks = queries.getConversationChunkCount(conversationId);
-      let chunks;
-      if (allChunks || totalChunks <= chunkLimit) {
-        chunks = queries.getConversationChunks(conversationId);
-      } else {
-        chunks = queries.getRecentConversationChunks(conversationId, chunkLimit);
-      }
-      const msgResult = queries.getPaginatedMessages(conversationId, 100, 0);
-      const rateLimitInfo = rateLimitState.get(conversationId) || null;
-            sendJSON(req, res, 200, {
-        conversation: conv,
-        isActivelyStreaming,
-        latestSession,
-        chunks,
-        totalChunks,
-        messages: msgResult.messages,
-        rateLimitInfo
-      });
-      return;
-    }
-
-    const conversationChunksMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/chunks$/);
-    if (conversationChunksMatch && req.method === 'GET') {
-      const conversationId = conversationChunksMatch[1];
-      const conv = queries.getConversation(conversationId);
-      if (!conv) { sendJSON(req, res, 404, { error: 'Conversation not found' }); return; }
-
-      const url = new URL(req.url, 'http://localhost');
-      const since = parseInt(url.searchParams.get('since') || '0');
-      const all = url.searchParams.get('all') === 'true';
-      const totalChunks = queries.getConversationChunkCount(conversationId);
-      let chunks;
-      if (since > 0) {
-        chunks = queries.getConversationChunksSince(conversationId, since);
-      } else if (all) {
-        chunks = queries.getConversationChunks(conversationId);
-      } else {
-        chunks = queries.getRecentConversationChunks(conversationId, 500);
-      }
-      debugLog(`[chunks] Conv ${conversationId}: ${chunks.length} chunks (total: ${totalChunks})`);
-      sendJSON(req, res, 200, { ok: true, chunks, totalChunks });
-      return;
-    }
-
-    const sessionChunksMatch = pathOnly.match(/^\/api\/sessions\/([^/]+)\/chunks$/);
-    if (sessionChunksMatch && req.method === 'GET') {
-      const sessionId = sessionChunksMatch[1];
-      const sess = queries.getSession(sessionId);
-      if (!sess) { sendJSON(req, res, 404, { error: 'Session not found' }); return; }
-
-      const url = new URL(req.url, 'http://localhost');
-      const sinceSeq = parseInt(url.searchParams.get('sinceSeq') || '-1');
-      const since = parseInt(url.searchParams.get('since') || '0');
-
-      let chunks;
-      if (sinceSeq >= 0) {
-        chunks = queries.getChunksSinceSeq(sessionId, sinceSeq);
-      } else {
-        chunks = queries.getChunksSince(sessionId, since);
-      }
-            sendJSON(req, res, 200, { ok: true, chunks });
-      return;
-    }
-
-    if (pathOnly.match(/^\/api\/conversations\/([^/]+)\/sessions\/latest$/) && req.method === 'GET') {
-      const convId = pathOnly.match(/^\/api\/conversations\/([^/]+)\/sessions\/latest$/)[1];
-      const latestSession = queries.getLatestSession(convId);
-      if (!latestSession) {
-                sendJSON(req, res, 200, { session: null });
-        return;
-      }
-      const events = queries.getSessionEvents(latestSession.id);
-            sendJSON(req, res, 200, { session: latestSession, events });
-      return;
-    }
-
-    const executionMatch = pathOnly.match(/^\/api\/sessions\/([^/]+)\/execution$/);
-    if (executionMatch && req.method === 'GET') {
-      const sessionId = executionMatch[1];
-      const url = new URL(req.url, 'http://localhost');
-      const limit = Math.min(parseInt(url.searchParams.get('limit') || '1000'), 5000);
-      const offset = Math.max(parseInt(url.searchParams.get('offset') || '0'), 0);
-      const filterType = url.searchParams.get('filterType');
-
-      try {
-        const session = queries.getSession(sessionId);
-        const allChunks = session ? (queries.getChunksSince(sessionId, 0) || []) : [];
-        const filtered = filterType ? allChunks.filter(e => e.type === filterType) : allChunks;
-        const executionData = {
-          sessionId,
-          events: filtered.slice(offset, offset + limit),
-          total: filtered.length,
-          limit,
-          offset,
-          hasMore: offset + limit < filtered.length,
-          metadata: {
-            status: session?.status || 'unknown',
-            startTime: session?.created_at || null,
-            duration: session?.completed_at && session?.created_at ? session.completed_at - session.created_at : 0,
-            eventCount: filtered.length
-          }
-        };
-
-        sendJSON(req, res, 200, executionData);
-      } catch (err) {
-                sendJSON(req, res, 400, { error: err.message });
-      }
-      return;
-    }
-
-    const runsMatch = pathOnly.match(/^\/api\/runs$/);
-    if (runsMatch && req.method === 'POST') {
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const { input, agentId, webhook } = parsed;
-      if (!input) {
-        sendJSON(req, res, 400, { error: 'Missing input in request body' });
-        return;
-      }
-
-      const resolvedAgentId = agentId || 'claude-code';
-      const resolvedModel = parsed.model || null;
-      const cwd = parsed.workingDirectory || STARTUP_CWD;
-
-      const thread = queries.createConversation(resolvedAgentId, 'Stateless Run', cwd);
-      const session = queries.createSession(thread.id, resolvedAgentId, 'pending');
-      const message = queries.createMessage(thread.id, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-      processMessageWithStreaming(thread.id, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-      sendJSON(req, res, 200, {
-        id: session.id,
-        status: 'pending',
-        started_at: session.started_at,
-        agentId: resolvedAgentId
-      });
-      return;
-    }
-
-    const runsSearchMatch = pathOnly.match(/^\/api\/runs\/search$/);
-    if (runsSearchMatch && req.method === 'POST') {
-      const sessions = queries.getAllSessions();
-      const runs = sessions.slice(0, 50).map(s => ({
-        id: s.id,
-        status: s.status,
-        started_at: s.started_at,
-        completed_at: s.completed_at,
-        agentId: s.agentId,
-        input: null,
-        output: null
-      })).reverse();
-      sendJSON(req, res, 200, runs);
-      return;
-    }
-
-    // POST /runs/stream - SSE removed, use WebSocket
-    if (pathOnly === '/api/runs/stream' && req.method === 'POST') {
-      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
-      return;
-    }
-
-    const scriptsMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/scripts$/);
-    if (scriptsMatch && req.method === 'GET') {
-      const conv = queries.getConversation(scriptsMatch[1]);
-      if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-      const wd = conv.workingDirectory || STARTUP_CWD;
-      let hasStart = false, hasDev = false;
-      try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
-        const scripts = pkg.scripts || {};
-        hasStart = !!scripts.start;
-        hasDev = !!scripts.dev;
-      } catch {}
-      const running = activeScripts.has(scriptsMatch[1]);
-      const runningScript = running ? activeScripts.get(scriptsMatch[1]).script : null;
-      sendJSON(req, res, 200, { hasStart, hasDev, running, runningScript });
-      return;
-    }
-
-    const runScriptMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/run-script$/);
-    if (runScriptMatch && req.method === 'POST') {
-      const conversationId = runScriptMatch[1];
-      const conv = queries.getConversation(conversationId);
-      if (!conv) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-      if (activeScripts.has(conversationId)) { sendJSON(req, res, 409, { error: 'Script already running' }); return; }
-      const body = await parseBody(req);
-      const script = body.script;
-      if (script !== 'start' && script !== 'dev') { sendJSON(req, res, 400, { error: 'Invalid script' }); return; }
-      const wd = conv.workingDirectory || STARTUP_CWD;
-      try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
-        if (!pkg.scripts || !pkg.scripts[script]) { sendJSON(req, res, 400, { error: `Script "${script}" not found` }); return; }
-      } catch { sendJSON(req, res, 400, { error: 'No package.json' }); return; }
-
-      const childEnv = { ...process.env, FORCE_COLOR: '1' };
-      delete childEnv.PORT;
-      delete childEnv.BASE_URL;
-      delete childEnv.HOT_RELOAD;
-      const isWindows = os.platform() === 'win32';
-      const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
-      activeScripts.set(conversationId, { process: child, script, startTime: Date.now() });
-      broadcastSync({ type: 'script_started', conversationId, script, timestamp: Date.now() });
-
-      const onData = (stream) => (chunk) => {
-        broadcastSync({ type: 'script_output', conversationId, data: chunk.toString(), stream, timestamp: Date.now() });
-      };
-      child.stdout.on('data', onData('stdout'));
-      child.stderr.on('data', onData('stderr'));
-      child.stdout.on('error', () => {});
-      child.stderr.on('error', () => {});
-      child.on('error', (err) => {
-        activeScripts.delete(conversationId);
-        broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: err.message, timestamp: Date.now() });
-      });
-      child.on('close', (code) => {
-        activeScripts.delete(conversationId);
-        broadcastSync({ type: 'script_stopped', conversationId, code: code || 0, timestamp: Date.now() });
-      });
-      sendJSON(req, res, 200, { ok: true, script, pid: child.pid });
-      return;
-    }
-
-    const stopScriptMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/stop-script$/);
-    if (stopScriptMatch && req.method === 'POST') {
-      const conversationId = stopScriptMatch[1];
-      const entry = activeScripts.get(conversationId);
-      if (!entry) { sendJSON(req, res, 404, { error: 'No running script' }); return; }
-      try { process.kill(-entry.process.pid, 'SIGTERM'); } catch { try { entry.process.kill('SIGTERM'); } catch {} }
-      sendJSON(req, res, 200, { ok: true });
-      return;
-    }
-
-    const scriptStatusMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/script-status$/);
-    if (scriptStatusMatch && req.method === 'GET') {
-      const entry = activeScripts.get(scriptStatusMatch[1]);
-      sendJSON(req, res, 200, { running: !!entry, script: entry?.script || null });
-      return;
-    }
-
-    const cancelRunMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/cancel$/);
-    if (cancelRunMatch && req.method === 'POST') {
-      const conversationId = cancelRunMatch[1];
-      const entry = activeExecutions.get(conversationId);
-      
-      if (!entry) {
-        sendJSON(req, res, 404, { error: 'No active execution to cancel' });
-        return;
-      }
-
-      const { pid, sessionId } = entry;
-      
-      if (pid) {
-        try {
-          process.kill(-pid, 'SIGKILL');
-        } catch {
-          try {
-            process.kill(pid, 'SIGKILL');
-          } catch (e) {}
-        }
-      }
-
-      if (sessionId) {
-        queries.updateSession(sessionId, { 
-          status: 'interrupted', 
-          completed_at: Date.now() 
-        });
-      }
-
-      queries.setIsStreaming(conversationId, false);
-      activeExecutions.delete(conversationId);
-
-      broadcastSync({
-        type: 'streaming_complete',
-        sessionId,
-        conversationId,
-        interrupted: true,
-        timestamp: Date.now()
-      });
+    const messagesHandler = _messagesRoutes._match(req.method, pathOnly);
+    if (messagesHandler) { await messagesHandler(req, res); return; }
 
-      sendJSON(req, res, 200, { ok: true, cancelled: true, conversationId, sessionId });
-      return;
-    }
+    const sessionsHandler = _sessionsRoutes._match(req.method, pathOnly);
+    if (sessionsHandler) { await sessionsHandler(req, res); return; }
 
-    const resumeRunMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/resume$/);
-    if (resumeRunMatch && req.method === 'POST') {
-      const conversationId = resumeRunMatch[1];
-      const conv = queries.getConversation(conversationId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Conversation not found' });
-        return;
-      }
+    const scriptsHandler = _scriptsRoutes._match(req.method, pathOnly);
+    if (scriptsHandler) { await scriptsHandler(req, res); return; }
 
-      const activeEntry = activeExecutions.get(conversationId);
-      if (activeEntry) {
-        sendJSON(req, res, 409, { error: 'Conversation already has an active execution' });
-        return;
-      }
-
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const { content, agentId } = parsed;
-      if (!content) {
-        sendJSON(req, res, 400, { error: 'Missing content in request body' });
-        return;
-      }
-
-      const resolvedAgentId = agentId || conv.agentId || 'claude-code';
-      const resolvedModel = parsed.model || conv.model || null;
-      const cwd = conv.workingDirectory || STARTUP_CWD;
-
-      const session = queries.createSession(conversationId, resolvedAgentId, 'pending');
-      
-      const message = queries.createMessage(conversationId, 'user', content);
-
-      processMessageWithStreaming(conversationId, message.id, session.id, content, resolvedAgentId, resolvedModel);
-
-      sendJSON(req, res, 200, { 
-        ok: true, 
-        conversationId, 
-        sessionId: session.id,
-        messageId: message.id,
-        resumed: true 
-      });
-      return;
-    }
-
-    const injectMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/inject$/);
-    if (injectMatch && req.method === 'POST') {
-      const conversationId = injectMatch[1];
-      const conv = queries.getConversation(conversationId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Conversation not found' });
-        return;
-      }
-
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const { content, eager } = parsed;
-      if (!content) {
-        sendJSON(req, res, 400, { error: 'Missing content in request body' });
-        return;
-      }
-
-      const entry = activeExecutions.get(conversationId);
-      
-      if (entry && eager) {
-        sendJSON(req, res, 409, { error: 'Cannot eagerly inject while execution is running - message queued' });
-        return;
-      }
-
-      const message = queries.createMessage(conversationId, 'user', '[INJECTED] ' + content);
-
-      if (!entry) {
-        const resolvedAgentId = conv.agentId || 'claude-code';
-        const resolvedModel = conv.model || null;
-        const cwd = conv.workingDirectory || STARTUP_CWD;
-        const session = queries.createSession(conversationId, resolvedAgentId, 'pending');
-        processMessageWithStreaming(conversationId, message.id, session.id, message.content, resolvedAgentId, resolvedModel);
-      }
-
-      sendJSON(req, res, 200, { ok: true, injected: true, conversationId, messageId: message.id });
-      return;
-    }
+    const runsHandlerA = _runsRoutes._match(req.method, pathOnly);
+    if (runsHandlerA) { await runsHandlerA(req, res); return; }
 
     const agentHandler = _agentRoutes._match(req.method, pathOnly);
     if (agentHandler) { await agentHandler(req, res); return; }
 
-    if (pathOnly === '/api/runs' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const { agent_id, input, config, webhook_url } = body;
-      if (!agent_id) {
-        sendJSON(req, res, 422, { error: 'agent_id is required' });
-        return;
-      }
-      const agent = discoveredAgents.find(a => a.id === agent_id);
-      if (!agent) {
-        sendJSON(req, res, 404, { error: 'Agent not found' });
-        return;
-      }
-      const run = queries.createRun(agent_id, null, input, config, webhook_url);
-      sendJSON(req, res, 201, run);
-      return;
-    }
-
-    if (pathOnly === '/api/runs/search' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const result = queries.searchRuns(body);
-      sendJSON(req, res, 200, result);
-      return;
-    }
-
-    if (pathOnly === '/api/runs/wait' && req.method === 'POST') {
-      const body = await parseBody(req);
-      const { agent_id, input, config } = body;
-      if (!agent_id) {
-        sendJSON(req, res, 422, { error: 'agent_id is required' });
-        return;
-      }
-      const agent = discoveredAgents.find(a => a.id === agent_id);
-      if (!agent) {
-        sendJSON(req, res, 404, { error: 'Agent not found' });
-        return;
-      }
-      const run = queries.createRun(agent_id, null, input, config);
-      const statelessThreadId = queries.getRun(run.run_id)?.thread_id;
-      if (statelessThreadId && input?.content) {
-        try {
-          await runClaudeWithStreaming(agent_id, statelessThreadId, input.content, config?.model || null);
-          const finalRun = queries.getRun(run.run_id);
-          sendJSON(req, res, 200, finalRun);
-        } catch (err) {
-          queries.updateRunStatus(run.run_id, 'error');
-          sendJSON(req, res, 500, { error: err.message });
-        }
-      } else {
-        sendJSON(req, res, 200, run);
-      }
-      return;
-    }
-
-    const oldRunByIdMatch1 = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
-    if (oldRunByIdMatch1) {
-      const runId = oldRunByIdMatch1[1];
-
-      if (req.method === 'GET') {
-        const run = queries.getRun(runId);
-        if (!run) {
-          sendJSON(req, res, 404, { error: 'Run not found' });
-          return;
-        }
-        sendJSON(req, res, 200, run);
-        return;
-      }
-
-      if (req.method === 'POST') {
-        const body = await parseBody(req);
-        const run = queries.getRun(runId);
-        if (!run) {
-          sendJSON(req, res, 404, { error: 'Run not found' });
-          return;
-        }
-        if (run.status !== 'pending') {
-          sendJSON(req, res, 409, { error: 'Run is not resumable' });
-          return;
-        }
-        if (body.input?.content && run.thread_id) {
-          runClaudeWithStreaming(run.agent_id, run.thread_id, body.input.content, null).catch(() => {});
-        }
-        sendJSON(req, res, 200, run);
-        return;
-      }
-
-      if (req.method === 'DELETE') {
-        try {
-          queries.deleteRun(runId);
-          res.writeHead(204);
-          res.end();
-        } catch (err) {
-          sendJSON(req, res, 404, { error: 'Run not found' });
-        }
-        return;
-      }
-    }
-
-    const runWaitMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/wait$/);
-    if (runWaitMatch && req.method === 'GET') {
-      const runId = runWaitMatch[1];
-      const run = queries.getRun(runId);
-      if (!run) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-      const startTime = Date.now();
-      const pollInterval = setInterval(() => {
-        const currentRun = queries.getRun(runId);
-        const elapsed = Date.now() - startTime;
-        const done = currentRun && ['success', 'error', 'cancelled'].includes(currentRun.status);
-        if (done) {
-          clearInterval(pollInterval);
-          sendJSON(req, res, 200, currentRun);
-        } else if (elapsed > 30000) {
-          clearInterval(pollInterval);
-          sendJSON(req, res, 408, { error: 'Run still pending after 30s', run_id: runId, status: currentRun?.status || run.status });
-        }
-      }, 500);
-      req.on('close', () => clearInterval(pollInterval));
-      return;
-    }
-
-    const runStreamMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/stream$/);
-    if (runStreamMatch && req.method === 'GET') {
-      res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' }));
-      return;
-    }
-
-    const oldRunCancelMatch1 = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
-    if (oldRunCancelMatch1 && req.method === 'POST') {
-      const runId = oldRunCancelMatch1[1];
-      try {
-        const run = queries.getRun(runId);
-        if (!run) {
-          sendJSON(req, res, 404, { error: 'Run not found' });
-          return;
-        }
-
-        if (['success', 'error', 'cancelled'].includes(run.status)) {
-          sendJSON(req, res, 409, { error: 'Run already completed or cancelled' });
-          return;
-        }
-
-        const cancelledRun = queries.cancelRun(runId);
-
-        const threadId = run.thread_id;
-        if (threadId) {
-          const execution = activeExecutions.get(threadId);
-          if (execution?.pid) {
-            try {
-              process.kill(-execution.pid, 'SIGTERM');
-            } catch {
-              try {
-                process.kill(execution.pid, 'SIGTERM');
-              } catch (e) {
-                console.error(`[cancel] Failed to SIGTERM PID ${execution.pid}:`, e.message);
-              }
-            }
-
-            setTimeout(() => {
-              try {
-                process.kill(-execution.pid, 'SIGKILL');
-              } catch {
-                try {
-                  process.kill(execution.pid, 'SIGKILL');
-                } catch (e) {}
-              }
-            }, 3000);
-          }
-
-          if (execution?.sessionId) {
-            queries.updateSession(execution.sessionId, {
-              status: 'error',
-              error: 'Cancelled by user',
-              completed_at: Date.now()
-            });
-          }
-
-          activeExecutions.delete(threadId);
-          queries.setIsStreaming(threadId, false);
-
-          broadcastSync({
-            type: 'streaming_cancelled',
-            sessionId: execution?.sessionId || runId,
-            conversationId: threadId,
-            runId: runId,
-            timestamp: Date.now()
-          });
-        }
-
-        sendJSON(req, res, 200, cancelledRun);
-      } catch (err) {
-        if (err.message === 'Run not found') {
-          sendJSON(req, res, 404, { error: err.message });
-        } else if (err.message.includes('already completed')) {
-          sendJSON(req, res, 409, { error: err.message });
-        } else {
-          sendJSON(req, res, 500, { error: err.message });
-        }
-      }
-      return;
-    }
-
-    const threadRunCancelMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/cancel$/);
-    if (threadRunCancelMatch && req.method === 'POST') {
-      const threadId = threadRunCancelMatch[1];
-      const runId = threadRunCancelMatch[2];
-
-      try {
-        const run = queries.getRun(runId);
-        if (!run) {
-          sendJSON(req, res, 404, { error: 'Run not found' });
-          return;
-        }
-
-        if (run.thread_id !== threadId) {
-          sendJSON(req, res, 400, { error: 'Run does not belong to specified thread' });
-          return;
-        }
-
-        if (['success', 'error', 'cancelled'].includes(run.status)) {
-          sendJSON(req, res, 409, { error: 'Run already completed or cancelled' });
-          return;
-        }
-
-        const cancelledRun = queries.cancelRun(runId);
-
-        const execution = activeExecutions.get(threadId);
-        if (execution?.pid) {
-          try {
-            process.kill(-execution.pid, 'SIGTERM');
-          } catch {
-            try {
-              process.kill(execution.pid, 'SIGTERM');
-            } catch (e) {
-              console.error(`[cancel] Failed to SIGTERM PID ${execution.pid}:`, e.message);
-            }
-          }
-
-          setTimeout(() => {
-            try {
-              process.kill(-execution.pid, 'SIGKILL');
-            } catch {
-              try {
-                process.kill(execution.pid, 'SIGKILL');
-              } catch (e) {}
-            }
-          }, 3000);
-        }
-
-        if (execution?.sessionId) {
-          queries.updateSession(execution.sessionId, {
-            status: 'error',
-            error: 'Cancelled by user',
-            completed_at: Date.now()
-          });
-        }
-
-        activeExecutions.delete(threadId);
-        activeProcessesByRunId.delete(runId);
-        queries.setIsStreaming(threadId, false);
-
-        broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: execution?.sessionId, timestamp: Date.now() });
-        broadcastSync({ type: 'streaming_cancelled', sessionId: execution?.sessionId || runId, conversationId: threadId, runId, timestamp: Date.now() });
-
-        sendJSON(req, res, 200, cancelledRun);
-      } catch (err) {
-        if (err.message === 'Run not found') {
-          sendJSON(req, res, 404, { error: err.message });
-        } else if (err.message.includes('already completed')) {
-          sendJSON(req, res, 409, { error: err.message });
-        } else {
-          sendJSON(req, res, 500, { error: err.message });
-        }
-      }
-      return;
-    }
-
-    const threadRunWaitMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/wait$/);
-    if (threadRunWaitMatch && req.method === 'GET') {
-      const threadId = threadRunWaitMatch[1];
-      const runId = threadRunWaitMatch[2];
-
-      const run = queries.getRun(runId);
-      if (!run) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      if (run.thread_id !== threadId) {
-        sendJSON(req, res, 400, { error: 'Run does not belong to specified thread' });
-        return;
-      }
-
-      const startTime = Date.now();
-      const pollInterval = setInterval(() => {
-        const currentRun = queries.getRun(runId);
-        const elapsed = Date.now() - startTime;
-        const done = currentRun && ['success', 'error', 'cancelled'].includes(currentRun.status);
-        if (done) {
-          clearInterval(pollInterval);
-          sendJSON(req, res, 200, currentRun);
-        } else if (elapsed > 30000) {
-          clearInterval(pollInterval);
-          sendJSON(req, res, 408, { error: 'Run still pending after 30s', run_id: runId, status: currentRun?.status || run.status });
-        }
-      }, 500);
-      req.on('close', () => clearInterval(pollInterval));
-      return;
-    }
-
     const oauthHandler = _oauthRoutes._match(req.method, pathOnly);
     if (oauthHandler) { await oauthHandler(req, res); return; }
 
-    const agentAuthMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/auth$/);
-    if (agentAuthMatch && req.method === 'POST') {
-      const agentId = agentAuthMatch[1];
-      const agent = discoveredAgents.find(a => a.id === agentId);
-      if (!agent) { sendJSON(req, res, 404, { error: 'Agent not found' }); return; }
+    const agentActionsHandler = _agentActionsRoutes._match(req.method, pathOnly);
+    if (agentActionsHandler) { await agentActionsHandler(req, res); return; }
 
-      if (agentId === 'codex' || agentId === 'cli-codex') {
-        try {
-          const result = await startCodexOAuth(req, { PORT, BASE_URL });
-          const conversationId = '__agent_auth__';
-          broadcastSync({ type: 'script_started', conversationId, script: 'auth-codex', agentId: 'codex', timestamp: Date.now() });
-          broadcastSync({ type: 'script_output', conversationId, data: `\x1b[36mOpening OpenAI OAuth in your browser...\x1b[0m\r\n\r\nIf it doesn't open automatically, visit:\r\n${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
-
-          const pollId = setInterval(() => {
-            if (getCodexOAuthState().status === 'success') {
-              clearInterval(pollId);
-              const email = getCodexOAuthState().email || '';
-              broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[32mAuthentication successful${email ? ' (' + email + ')' : ''}\x1b[0m\r\n`, stream: 'stdout', timestamp: Date.now() });
-              broadcastSync({ type: 'script_stopped', conversationId, code: 0, timestamp: Date.now() });
-            } else if (getCodexOAuthState().status === 'error') {
-              clearInterval(pollId);
-              broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[31mAuthentication failed: ${getCodexOAuthState().error}\x1b[0m\r\n`, stream: 'stderr', timestamp: Date.now() });
-              broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: getCodexOAuthState().error, timestamp: Date.now() });
-            }
-          }, 1000);
-
-          setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
-
-          sendJSON(req, res, 200, { ok: true, agentId, authUrl: result.authUrl, mode: result.mode });
-          return;
-        } catch (e) {
-          console.error('[codex-oauth] /api/agents/codex/auth failed:', e);
-          sendJSON(req, res, 500, { error: e.message });
-          return;
-        }
-      }
-
-      if (agentId === 'gemini') {
-        try {
-          const result = await startGeminiOAuth(req, { PORT, BASE_URL, rootDir });
-          const conversationId = '__agent_auth__';
-          broadcastSync({ type: 'script_started', conversationId, script: 'auth-gemini', agentId: 'gemini', timestamp: Date.now() });
-          broadcastSync({ type: 'script_output', conversationId, data: `\x1b[36mOpening Google OAuth in your browser...\x1b[0m\r\n\r\nIf it doesn't open automatically, visit:\r\n${result.authUrl}\r\n`, stream: 'stdout', timestamp: Date.now() });
-
-          const pollId = setInterval(() => {
-            if (getGeminiOAuthState().status === 'success') {
-              clearInterval(pollId);
-              const email = getGeminiOAuthState().email || '';
-              broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[32mAuthentication successful${email ? ' (' + email + ')' : ''}\x1b[0m\r\n`, stream: 'stdout', timestamp: Date.now() });
-              broadcastSync({ type: 'script_stopped', conversationId, code: 0, timestamp: Date.now() });
-            } else if (getGeminiOAuthState().status === 'error') {
-              clearInterval(pollId);
-              broadcastSync({ type: 'script_output', conversationId, data: `\r\n\x1b[31mAuthentication failed: ${getGeminiOAuthState().error}\x1b[0m\r\n`, stream: 'stderr', timestamp: Date.now() });
-              broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: getGeminiOAuthState().error, timestamp: Date.now() });
-            }
-          }, 1000);
-
-          setTimeout(() => clearInterval(pollId), 5 * 60 * 1000);
-
-          sendJSON(req, res, 200, { ok: true, agentId, authUrl: result.authUrl, mode: result.mode });
-          return;
-        } catch (e) {
-          console.error('[gemini-oauth] /api/agents/gemini/auth failed:', e);
-          sendJSON(req, res, 500, { error: e.message });
-          return;
-        }
-      }
-
-      const authCommands = {
-        'claude-code': { cmd: 'claude', args: ['setup-token'] },
-        'opencode': { cmd: 'opencode', args: ['auth', 'login'] },
-      };
-      const authCmd = authCommands[agentId];
-      if (!authCmd) { sendJSON(req, res, 400, { error: 'No auth command for this agent' }); return; }
-
-      const conversationId = '__agent_auth__';
-      if (activeScripts.has(conversationId)) {
-        sendJSON(req, res, 409, { error: 'Auth process already running' });
-        return;
-      }
-
-      const child = spawn(authCmd.cmd, authCmd.args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, FORCE_COLOR: '1' },
-        shell: os.platform() === 'win32'
-      });
-      activeScripts.set(conversationId, { process: child, script: 'auth-' + agentId, startTime: Date.now() });
-      broadcastSync({ type: 'script_started', conversationId, script: 'auth-' + agentId, agentId, timestamp: Date.now() });
-
-      const onData = (stream) => (chunk) => {
-        broadcastSync({ type: 'script_output', conversationId, data: chunk.toString(), stream, timestamp: Date.now() });
-      };
-      child.stdout.on('data', onData('stdout'));
-      child.stderr.on('data', onData('stderr'));
-      child.stdout.on('error', () => {});
-      child.stderr.on('error', () => {});
-      child.on('error', (err) => {
-        activeScripts.delete(conversationId);
-        broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: err.message, timestamp: Date.now() });
-      });
-      child.on('close', (code) => {
-        activeScripts.delete(conversationId);
-        broadcastSync({ type: 'script_stopped', conversationId, code: code || 0, timestamp: Date.now() });
-      });
-      sendJSON(req, res, 200, { ok: true, agentId, pid: child.pid });
-      return;
-    }
-
-    const agentUpdateMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/update$/);
-    if (agentUpdateMatch && req.method === 'POST') {
-      const agentId = agentUpdateMatch[1];
-      const updateCommands = {
-        'claude-code': { cmd: 'claude', args: ['update', '--yes'] },
-      };
-      const updateCmd = updateCommands[agentId];
-      if (!updateCmd) { sendJSON(req, res, 400, { error: 'No update command for this agent' }); return; }
-      const conversationId = '__agent_update__';
-      if (activeScripts.has(conversationId)) { sendJSON(req, res, 409, { error: 'Update already running' }); return; }
-      const child = spawn(updateCmd.cmd, updateCmd.args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, FORCE_COLOR: '1' },
-        shell: os.platform() === 'win32'
-      });
-      activeScripts.set(conversationId, { process: child, script: 'update-' + agentId, startTime: Date.now() });
-      broadcastSync({ type: 'script_started', conversationId, script: 'update-' + agentId, agentId, timestamp: Date.now() });
-      const onData = (stream) => (chunk) => {
-        broadcastSync({ type: 'script_output', conversationId, data: chunk.toString(), stream, timestamp: Date.now() });
-      };
-      child.stdout.on('data', onData('stdout'));
-      child.stderr.on('data', onData('stderr'));
-      child.stdout.on('error', () => {});
-      child.stderr.on('error', () => {});
-      child.on('error', (err) => {
-        activeScripts.delete(conversationId);
-        broadcastSync({ type: 'script_stopped', conversationId, code: 1, error: err.message, timestamp: Date.now() });
-      });
-      child.on('close', (code) => {
-        activeScripts.delete(conversationId);
-        modelCache.delete(agentId);
-        broadcastSync({ type: 'script_stopped', conversationId, code: code || 0, timestamp: Date.now() });
-      });
-      sendJSON(req, res, 200, { ok: true, agentId, pid: child.pid });
-      return;
-    }
-
-    if (pathOnly === '/api/auth/configs' && req.method === 'GET') {
-      const configs = getProviderConfigs();
-      sendJSON(req, res, 200, configs);
-      return;
-    }
-
-    if (pathOnly === '/api/auth/save-config' && req.method === 'POST') {
-      try {
-        const body = await parseBody(req);
-        const { providerId, apiKey, defaultModel } = body || {};
-        if (typeof providerId !== 'string' || !providerId.length || providerId.length > 100) {
-          sendJSON(req, res, 400, { error: 'Invalid providerId' }); return;
-        }
-        if (typeof apiKey !== 'string' || !apiKey.length || apiKey.length > 10000) {
-          sendJSON(req, res, 400, { error: 'Invalid apiKey' }); return;
-        }
-        if (defaultModel !== undefined && (typeof defaultModel !== 'string' || defaultModel.length > 200)) {
-          sendJSON(req, res, 400, { error: 'Invalid defaultModel' }); return;
-        }
-        const configPath = saveProviderConfig(providerId, apiKey, defaultModel || '');
-        sendJSON(req, res, 200, { success: true, path: configPath });
-      } catch (err) {
-        sendJSON(req, res, 400, { error: err.message });
-      }
-      return;
-    }
+    const authConfigHandler = _authConfigRoutes._match(req.method, pathOnly);
+    if (authConfigHandler) { await authConfigHandler(req, res); return; }
 
     const speechHandler = _speechRoutes._match(req.method, pathOnly);
     if (speechHandler) { await speechHandler(req, res, pathOnly); return; }
@@ -1659,680 +649,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 +741,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();
 
@@ -2437,6 +770,12 @@ const _threadRoutes = registerThreadRoutes({ sendJSON, parseBody, queries });
 const _debugRoutes = registerDebugRoutes({ sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath });
 const _convRoutes = registerConvRoutes({ sendJSON, parseBody, queries, activeExecutions, broadcastSync });
 const _agentRoutes = registerAgentRoutes({ sendJSON, parseBody, queries, discoveredAgents, getACPStatus, modelCache, getModelsForAgent, debugLog });
+const _messagesRoutes = registerMessagesRoutes({ queries, sendJSON, parseBody, broadcastSync, processMessageWithStreaming, activeExecutions, messageQueues, debugLog, logError });
+const _sessionsRoutes = registerSessionsRoutes({ queries, sendJSON, activeExecutions, rateLimitState, debugLog });
+const _runsRoutes = registerRunsRoutes({ sendJSON, parseBody, queries, broadcastSync, processMessageWithStreaming, activeExecutions, activeProcessesByRunId, discoveredAgents, STARTUP_CWD });
+const _scriptsRoutes = registerScriptsRoutes({ sendJSON, parseBody, queries, broadcastSync, activeScripts, activeExecutions, processMessageWithStreaming, STARTUP_CWD });
+const _agentActionsRoutes = registerAgentActionsRoutes({ sendJSON, queries, broadcastSync, discoveredAgents, activeScripts, startGeminiOAuth, startCodexOAuth, getGeminiOAuthState, getCodexOAuthState, modelCache, PORT, BASE_URL, rootDir });
+const _authConfigRoutes = registerAuthConfigRoutes({ sendJSON, parseBody, getProviderConfigs, saveProviderConfig });
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, rateLimitState,