agentgui 1.0.857 → 1.0.859

package/lib/db-queries-tools.js

@@ -76,6 +76,10 @@ export function addToolQueries(q, db, prep, generateId) {
 
   q.addToolInstallHistory = function(toolId, action, status, error) {
     const now = Date.now();
+    // Ensure the parent tool_installations row exists before inserting history
+    // (handles tools added after the DB was first initialized)
+    prep(`INSERT OR IGNORE INTO tool_installations (id, tool_id, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`)
+      .run(generateId('tinst'), toolId, 'not_installed', now, now);
     const stmt = prep(`
       INSERT INTO tool_install_history
       (id, tool_id, action, started_at, completed_at, status, error_message, created_at)

package/lib/http-handler.js

@@ -3,7 +3,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 
-export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, wss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }) {
+export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap, routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }) {
   return async function httpHandler(req, res) {
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
@@ -64,7 +64,7 @@ export function createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, ser
         try { queries._db.prepare('SELECT 1').get(); } catch (e) { dbStatus = { ok: false, error: e.message }; }
         const queueSizes = {};
         for (const [k, v] of messageQueues) queueSizes[k] = v.length;
-        sendJSON(req, res, 200, { status: 'ok', version: PKG_VERSION, uptime: process.uptime(), agents: discoveredAgents.length, activeExecutions: activeExecutions.size, wsClients: wss.clients.size, memory: process.memoryUsage(), acp: getACPStatus(), db: dbStatus, queueSizes });
+        sendJSON(req, res, 200, { status: 'ok', version: PKG_VERSION, uptime: process.uptime(), agents: discoveredAgents.length, activeExecutions: activeExecutions.size, wsClients: getWss()?.clients?.size ?? 0, memory: process.memoryUsage(), acp: getACPStatus(), db: dbStatus, queueSizes });
         return;
       }
 

package/lib/jsonl-parser.js

@@ -1,19 +1,9 @@
 import path from 'path';
-<<<<<<< HEAD
-
-export class JsonlParser {
-  constructor({ broadcastSync, queries, ownedSessionIds }) {
-    this._bc = broadcastSync;
-    this._q = queries;
-    this._owned = ownedSessionIds;
-=======
-import fs from 'fs';
 
 export class JsonlParser {
   constructor({ broadcastSync, queries }) {
     this._bc = broadcastSync;
     this._q = queries;
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     this._convMap = new Map();
     this._emitted = new Map();
     this._seqs = new Map();
@@ -21,8 +11,6 @@ export class JsonlParser {
     this._sessions = new Map();
   }
 
-<<<<<<< HEAD
-=======
   /**
    * Pre-register a GUI-spawned session so _conv finds the right conversation
    * and _dbSession reuses the existing session ID instead of creating a new one.
@@ -34,7 +22,6 @@ export class JsonlParser {
     if (dbSessionId) this._sessions.set(claudeSessionId, dbSessionId);
   }
 
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   clear() {
     this._convMap.clear();
     this._emitted.clear();
@@ -55,47 +42,23 @@ export class JsonlParser {
     for (const sid of [...this._streaming]) this._endStreaming(this._convMap.get(sid), sid);
   }
 
-<<<<<<< HEAD
-  _line(fp, line) {
-    line = line.trim(); if (!line) return;
-    let e; try { e = JSON.parse(line); } catch (_) { return; }
-    if (!e || !e.sessionId) return;
-    if (this._owned?.has(e.sessionId)) return;
-    const cid = this._conv(e.sessionId, e, fp);
-    if (cid) this._route(cid, e.sessionId, e);
-  }
-
-  _conv(sid, e) {
-=======
   _conv(sid, e, fp) {
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     if (this._convMap.has(sid)) return this._convMap.get(sid);
     const found = this._q.getConversations().find(c => c.claudeSessionId === sid);
     if (found) { this._convMap.set(sid, found.id); return found.id; }
     if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
     if (e.type === 'user' && e.isMeta) return null;
-<<<<<<< HEAD
-    const cwd = e.cwd || process.cwd();
-=======
 
-    // Resolve workingDirectory: event cwd → sessions-index.json → decoded path
+    // Resolve workingDirectory: event cwd → decode encoded directory name
     let cwd = e.cwd || null;
     if (!cwd && fp) {
       const projectDir = path.dirname(fp);
-      // Try sessions-index.json first (reliable, no ambiguity)
-      try {
-        const idx = JSON.parse(fs.readFileSync(path.join(projectDir, 'sessions-index.json'), 'utf-8'));
-        if (idx.originalPath) cwd = idx.originalPath;
-      } catch (_) {}
-      // Fallback: decode encoded directory name (replace leading '-' with '/', rest '-' → '/')
-      if (!cwd) {
-        const dirName = path.basename(projectDir);
-        if (dirName.startsWith('-')) cwd = '/' + dirName.slice(1).replace(/-/g, '/');
-      }
+      // Decode encoded directory name (replace leading '-' with '/', rest '-' → '/')
+      const dirName = path.basename(projectDir);
+      if (dirName.startsWith('-')) cwd = '/' + dirName.slice(1).replace(/-/g, '/');
     }
     cwd = cwd || process.cwd();
 
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     const branch = e.gitBranch || '';
     const base = path.basename(cwd);
     const title = branch ? `${branch} @ ${base}` : base;

package/lib/jsonl-watcher.js

@@ -3,11 +3,6 @@ import { JsonlWatcher as CCFWatcher } from 'ccfollow';
 import { JsonlParser } from './jsonl-parser.js';
 
 export class JsonlWatcher extends CCFWatcher {
-<<<<<<< HEAD
-  constructor({ broadcastSync, queries, ownedSessionIds }) {
-    super();
-    this._parser = new JsonlParser({ broadcastSync, queries, ownedSessionIds });
-=======
   constructor({ broadcastSync, queries }) {
     super();
     this._parser = new JsonlParser({ broadcastSync, queries });
@@ -19,7 +14,6 @@ export class JsonlWatcher extends CCFWatcher {
     this._currentFp = fp;
     super._read(fp);
     this._currentFp = null;
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   }
 
   _line(line) {
@@ -28,12 +22,6 @@ export class JsonlWatcher extends CCFWatcher {
     let e;
     try { e = JSON.parse(line); } catch (_) { return; }
     if (!e || !e.sessionId) return;
-<<<<<<< HEAD
-    const cid = this._parser._conv(e.sessionId, e);
-    if (cid) this._parser._route(cid, e.sessionId, e);
-  }
-
-=======
     const cid = this._parser._conv(e.sessionId, e, this._currentFp);
     if (cid) this._parser._route(cid, e.sessionId, e);
   }
@@ -47,7 +35,6 @@ export class JsonlWatcher extends CCFWatcher {
     this._parser.registerSession(claudeSessionId, convId, dbSessionId);
   }
 
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   stop() {
     super.stop();
     this._parser.endAllStreaming();

package/lib/process-message.js

@@ -1,8 +1,4 @@
-<<<<<<< HEAD
-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 }) {
-=======
 export function createProcessMessage({ queries, activeExecutions, rateLimitState, execMachine, broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager, discoveredAgents, STARTUP_CWD, buildSystemPrompt, parseRateLimitResetTime, eagerTTS, touchACP, getJsonlWatcher, debugLog, logError, scheduleRetry, drainMessageQueue, createEventHandler }) {
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
     const startTime = Date.now();
     touchACP(agentId);
@@ -31,33 +27,24 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
     execMachine.send(conversationId, { type: 'START', sessionId });
     queries.setIsStreaming(conversationId, true);
     queries.updateSession(sessionId, { status: 'active' });
-<<<<<<< HEAD
-    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 });
-=======
     const cwd = conv?.workingDirectory || STARTUP_CWD;
+    // Resolve agent before building stateRef so isJsonlBacked can be set correctly.
+    // claude-code (protocol: direct) writes JSONL → JsonlParser owns event broadcasting.
+    // All other agents (protocol: acp) rely solely on onEvent for streaming.
+    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 isJsonlBacked = resolvedAgentId === 'claude-code';
     // stateRef tracks eventCount (for session response metadata) and resumeSessionId
     const stateRef = { eventCount: 0, resumeSessionId: conv?.claudeSessionId || null };
-    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef: stateRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime });
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
+    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef: stateRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, isJsonlBacked, getJsonlWatcher, 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;
+      debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}, agent=${resolvedAgentId}, jsonlBacked=${isJsonlBacked}`);
       const resolvedModel = model || conv?.model || null;
       const resolvedSubAgent = subAgent || conv?.subAgent || null;
       const config = {
         verbose: true, outputFormat: 'stream-json', timeout: 1800000, print: true,
-<<<<<<< HEAD
-        resumeSessionId: batcherRef.resumeSessionId,
-=======
         resumeSessionId: stateRef.resumeSessionId,
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         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 }); },
@@ -70,19 +57,6 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
       }
       activeExecutions.delete(conversationId);
       execMachine.send(conversationId, { type: 'COMPLETE' });
-<<<<<<< HEAD
-      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);
-=======
       debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
       queries.updateSession(sessionId, { status: 'complete', response: JSON.stringify({ outputs, eventCount: stateRef.eventCount }), completed_at: Date.now() });
       // streaming_complete is broadcast by JsonlParser when it sees the turn_duration event.
@@ -93,7 +67,6 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
     } catch (error) {
       const elapsed = Date.now() - startTime;
       debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       if (rateLimitState.get(conversationId)?.isStreamDetected) {
         debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping catch handler`);
         return;
@@ -107,10 +80,6 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         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);
-<<<<<<< HEAD
-        batcher.drain();
-=======
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         activeExecutions.delete(conversationId);
         return;
       }
@@ -129,10 +98,6 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         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() });
-<<<<<<< HEAD
-        batcher.drain();
-=======
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         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`);
@@ -142,21 +107,13 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         }, cooldownMs);
         return;
       }
-<<<<<<< HEAD
-      const isSessionConflict = error.exitCode === null && batcherRef.eventCount === 0;
-=======
       const isSessionConflict = error.exitCode === null && stateRef.eventCount === 0;
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       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 {
-<<<<<<< HEAD
-      batcher.drain();
-=======
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       if (!rateLimitState.has(conversationId)) {
         cleanupExecution(conversationId);
         drainMessageQueue(conversationId);

package/lib/routes-tools.js

@@ -33,7 +33,7 @@ export function register(deps) {
   };
 
   routes['POST /api/tools/update'] = async (req, res) => {
-    const allToolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
+    const allToolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo', 'gm-codex'];
     sendJSON(req, res, 200, { updating: true, toolCount: allToolIds.length });
     broadcastSync({ type: 'tools_update_started', tools: allToolIds });
     setImmediate(async () => {

package/lib/server-startup.js

@@ -1,10 +1,6 @@
 import { JsonlWatcher } from './jsonl-watcher.js';
 
-<<<<<<< HEAD
-export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents, PORT, BASE_URL, watch, ownedSessionIds, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport, performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions }) {
-=======
 export function createOnServerReady({ queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents, PORT, BASE_URL, watch, setWatcher, resumeInterruptedStreams, activeExecutions, debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine, toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport, performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions }) {
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
   let jsonlWatcher = null;
 
   function getJsonlWatcher() { return jsonlWatcher; }
@@ -27,14 +23,9 @@ export function createOnServerReady({ queries, broadcastSync, warmAssetCache, st
     }, 6 * 60 * 60 * 1000);
 
     try {
-<<<<<<< HEAD
-      jsonlWatcher = new JsonlWatcher({ broadcastSync, queries, ownedSessionIds });
-      jsonlWatcher.start();
-=======
       jsonlWatcher = new JsonlWatcher({ broadcastSync, queries });
       jsonlWatcher.start();
       if (setWatcher) setWatcher(jsonlWatcher);
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
       console.log('[JSONL] Watcher started');
     } catch (err) { console.error('[JSONL] Watcher failed to start:', err.message); }
 
@@ -60,7 +51,7 @@ export function createOnServerReady({ queries, broadcastSync, warmAssetCache, st
       }, 6000);
     }).catch(err => console.error('[ACP] Startup error:', err.message));
 
-    const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo'];
+    const toolIds = ['cli-claude', 'cli-opencode', 'cli-gemini', 'cli-kilo', 'cli-codex', 'cli-agent-browser', 'gm-cc', 'gm-oc', 'gm-gc', 'gm-kilo', 'gm-codex'];
     queries.initializeToolInstallations(toolIds.map(id => ({ id })));
     console.log('[TOOLS] Starting background provisioning...');
 

package/lib/stream-event-handler.js

@@ -1,48 +1,21 @@
-<<<<<<< HEAD
-export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
-=======
 /**
- * Minimal Claude stdout event handler.
+ * Claude stdout event handler.
  *
- * Now that JsonlParser owns all event broadcasting (streaming_start,
- * streaming_progress, streaming_complete) via the JSONL file watcher,
- * this handler only needs to:
- *   1. Extract session_id → call setClaudeSessionId + registerSession so the
- *      parser links the file to the correct existing conversation/session.
- *   2. Detect inline rate-limit messages in text/result blocks → scheduleRetry.
+ * For claude-code (isJsonlBacked=true):
+ *   JsonlParser owns all event broadcasting via the JSONL file watcher.
+ *   This handler only needs to:
+ *     1. Extract session_id → setClaudeSessionId + registerSession
+ *     2. Detect inline rate-limit messages → scheduleRetry
  *
- * No batcher, no broadcastSync for individual blocks.
+ * For ACP agents (isJsonlBacked=false):
+ *   No JSONL file is written. This handler broadcasts streaming_start,
+ *   streaming_progress blocks, and persists chunks to the DB.
  */
-export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
+export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, isJsonlBacked, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
   return function onEvent(parsed) {
     batcherRef.eventCount++;
     const entry = activeExecutions.get(conversationId);
     if (entry) entry.lastActivity = Date.now();
-<<<<<<< HEAD
-    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() });
-=======
 
     // Register session with file watcher as soon as we see the session_id.
     // This pre-maps claudeSessionId → (convId, dbSessionId) in JsonlParser before
@@ -57,26 +30,48 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
 
     debugLog(`[stream] Event ${batcherRef.eventCount}: type=${parsed.type}`);
 
-    // Rate-limit detection in assistant text blocks
+    // --- ACP agent broadcasting (not backed by JSONL watcher) ---
+    if (!isJsonlBacked) {
+      // Send streaming_start on first event
+      if (batcherRef.eventCount === 1) {
+        queries.setIsStreaming(conversationId, true);
+        broadcastSync({ type: 'streaming_start', sessionId, conversationId, agentId, timestamp: Date.now() });
+      }
+
+      const emitBlock = (block, role, extra) => {
+        if (!block || !block.type) return;
+        batcherRef.currentSeq = (batcherRef.currentSeq || 0) + 1;
+        try { queries.createChunk(sessionId, conversationId, batcherRef.currentSeq, block.type, block); } catch (_) {}
+        broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: role, seq: batcherRef.currentSeq, timestamp: Date.now(), ...extra });
+      };
+
+      if (parsed.type === 'assistant' && parsed.message?.content) {
+        for (const block of parsed.message.content) emitBlock(block, 'assistant');
+      }
+
+      if (parsed.type === 'user' && parsed.message?.content) {
+        const blocks = Array.isArray(parsed.message.content) ? parsed.message.content : [];
+        for (const block of blocks) if (block?.type === 'tool_result') emitBlock(block, 'tool_result');
+      }
+
+      if (parsed.type === 'result') {
+        const block = { type: 'result', result: parsed.result, subtype: parsed.subtype, duration_ms: parsed.duration_ms, total_cost_usd: parsed.total_cost_usd, is_error: parsed.is_error || false };
+        emitBlock(block, 'result', { isResult: true });
+      }
+    }
+
+    // --- Rate-limit detection in assistant text blocks (all agents) ---
     if (parsed.type === 'assistant' && parsed.message?.content) {
       for (const block of parsed.message.content) {
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
         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);
-<<<<<<< HEAD
-            if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (e) {} }
-            const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
-            if (existingCount >= 3) {
-              batcherRef.batcher.drain();
-=======
             if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (_) {} }
             const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
             if (existingCount >= 3) {
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
               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.`);
@@ -86,10 +81,6 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
             }
             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() });
-<<<<<<< HEAD
-            batcherRef.batcher.drain();
-=======
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
             activeExecutions.delete(conversationId);
             queries.setIsStreaming(conversationId, false);
             setTimeout(() => {
@@ -102,64 +93,9 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
           eagerTTS(block.text, conversationId, sessionId);
         }
       }
-<<<<<<< HEAD
-    } 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() });
-=======
     }
 
-    // Rate-limit detection in result blocks
+    // --- Rate-limit detection in result blocks (all agents) ---
     if (parsed.type === 'result' && 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);
@@ -189,7 +125,6 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
         return;
       }
       if (resultText) eagerTTS(resultText, conversationId, sessionId);
->>>>>>> 6bfde951cbeb65ec72b73da9c23b9c8c0ba0bbc1
     }
   };
 }

package/package.json

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

package/server.js

@@ -98,7 +98,7 @@ const _assetDeps = { compressAndSend, acceptsEncoding, watch, BASE_URL, PKG_VERS
 function serveFile(filePath, res, req) { return _serveFile(filePath, res, req, _assetDeps); }
 
 const _routes = {};
-const server = http.createServer(createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, get wss() { return wss; }, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap: _rateLimitMap, routes: _routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }));
+const server = http.createServer(createHttpHandler({ BASE_URL, expressApp, queries, sendJSON, serveFile, staticDir, messageQueues, getWss: () => wss, activeExecutions, getACPStatus, discoveredAgents, PKG_VERSION, RATE_LIMIT_MAX, rateLimitMap: _rateLimitMap, routes: _routes, handleGeminiOAuthCallback, handleCodexOAuthCallback, PORT }));
 
 let broadcastSeq = 0;
 const syncClients = new Set();