agentgui 1.0.854 → 1.0.855

package/lib/jsonl-parser.js

@@ -1,10 +1,10 @@
 import path from 'path';
+import fs from 'fs';
 
 export class JsonlParser {
-  constructor({ broadcastSync, queries, ownedSessionIds }) {
+  constructor({ broadcastSync, queries }) {
     this._bc = broadcastSync;
     this._q = queries;
-    this._owned = ownedSessionIds;
     this._convMap = new Map();
     this._emitted = new Map();
     this._seqs = new Map();
@@ -12,6 +12,17 @@ export class JsonlParser {
     this._sessions = new Map();
   }
 
+  /**
+   * 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.
+   * Must be called as soon as session_id is obtained from Claude stdout, before
+   * the 16ms file-watcher debounce fires.
+   */
+  registerSession(claudeSessionId, convId, dbSessionId) {
+    this._convMap.set(claudeSessionId, convId);
+    if (dbSessionId) this._sessions.set(claudeSessionId, dbSessionId);
+  }
+
   clear() {
     this._convMap.clear();
     this._emitted.clear();
@@ -32,22 +43,30 @@ export class JsonlParser {
     for (const sid of [...this._streaming]) this._endStreaming(this._convMap.get(sid), sid);
   }
 
-  _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) {
     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;
-    const cwd = e.cwd || process.cwd();
+
+    // Resolve workingDirectory: event cwd → sessions-index.json → decoded path
+    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, '/');
+      }
+    }
+    cwd = cwd || process.cwd();
+
     const branch = e.gitBranch || '';
     const base = path.basename(cwd);
     const title = branch ? `${branch} @ ${base}` : base;

package/lib/jsonl-watcher.js

@@ -3,9 +3,17 @@ import { JsonlWatcher as CCFWatcher } from 'ccfollow';
 import { JsonlParser } from './jsonl-parser.js';
 
 export class JsonlWatcher extends CCFWatcher {
-  constructor({ broadcastSync, queries, ownedSessionIds }) {
+  constructor({ broadcastSync, queries }) {
     super();
-    this._parser = new JsonlParser({ broadcastSync, queries, ownedSessionIds });
+    this._parser = new JsonlParser({ broadcastSync, queries });
+    this._currentFp = null;
+  }
+
+  /** Override _read to capture the current file path for project-folder resolution in _conv */
+  _read(fp) {
+    this._currentFp = fp;
+    super._read(fp);
+    this._currentFp = null;
   }
 
   _line(line) {
@@ -14,10 +22,19 @@ export class JsonlWatcher extends CCFWatcher {
     let e;
     try { e = JSON.parse(line); } catch (_) { return; }
     if (!e || !e.sessionId) return;
-    const cid = this._parser._conv(e.sessionId, e);
+    const cid = this._parser._conv(e.sessionId, e, this._currentFp);
     if (cid) this._parser._route(cid, e.sessionId, e);
   }
 
+  /**
+   * Pre-register a GUI-spawned session so the parser uses the correct existing
+   * conversation and session ID rather than creating duplicates.
+   * Call this as soon as session_id is obtained from Claude stdout.
+   */
+  registerSession(claudeSessionId, convId, dbSessionId) {
+    this._parser.registerSession(claudeSessionId, convId, dbSessionId);
+  }
+
   stop() {
     super.stop();
     this._parser.endAllStreaming();

package/lib/process-message.js

@@ -1,4 +1,4 @@
-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 }) {
   async function processMessageWithStreaming(conversationId, messageId, sessionId, content, agentId, model, subAgent) {
     const startTime = Date.now();
     touchACP(agentId);
@@ -27,12 +27,10 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
     execMachine.send(conversationId, { type: 'START', sessionId });
     queries.setIsStreaming(conversationId, true);
     queries.updateSession(sessionId, { status: 'active' });
-    const batcher = createChunkBatcher(queries, debugLog);
     const cwd = conv?.workingDirectory || STARTUP_CWD;
-    const allBlocksRef = { val: [] };
-    const currentSequenceRef = { val: queries.getMaxSequence(sessionId) ?? -1 };
-    const batcherRef = { batcher, eventCount: 0, resumeSessionId: conv?.claudeSessionId || null };
-    const onEvent = createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, ownedSessionIds, allBlocksRef, currentSequenceRef, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime });
+    // 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 });
     try {
       debugLog(`[stream] Starting: conversationId=${conversationId}, sessionId=${sessionId}`);
       let resolvedAgentId = agentId || 'claude-code';
@@ -42,7 +40,7 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
       const resolvedSubAgent = subAgent || conv?.subAgent || null;
       const config = {
         verbose: true, outputFormat: 'stream-json', timeout: 1800000, print: true,
-        resumeSessionId: batcherRef.resumeSessionId,
+        resumeSessionId: stateRef.resumeSessionId,
         systemPrompt: buildSystemPrompt(agentId, resolvedModel, resolvedSubAgent),
         model: resolvedModel || undefined, subAgent: resolvedSubAgent || undefined, onEvent,
         onPid: (pid) => { const e = activeExecutions.get(conversationId); if (e) e.pid = pid; execMachine.send(conversationId, { type: 'SET_PID', pid }); },
@@ -55,17 +53,16 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
       }
       activeExecutions.delete(conversationId);
       execMachine.send(conversationId, { type: 'COMPLETE' });
-      batcher.drain();
-      if (claudeSessionId) ownedSessionIds.delete(claudeSessionId);
       debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
-      queries.updateSession(sessionId, { status: 'complete', response: JSON.stringify({ outputs, eventCount: batcherRef.eventCount }), completed_at: Date.now() });
-      broadcastSync({ type: 'streaming_complete', sessionId, conversationId, agentId, eventCount: batcherRef.eventCount, seq: currentSequenceRef.val, timestamp: Date.now() });
-      debugLog(`[stream] Completed: ${outputs.length} outputs, ${batcherRef.eventCount} events`);
+      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.
+      // We still broadcast here as a fallback for cases where the file watcher may not have
+      // processed the final event yet (e.g., ACP agents that don't write JSONL files).
+      broadcastSync({ type: 'streaming_complete', sessionId, conversationId, agentId, eventCount: stateRef.eventCount, timestamp: Date.now() });
+      debugLog(`[stream] Completed: ${outputs.length} outputs, ${stateRef.eventCount} events`);
     } catch (error) {
       const elapsed = Date.now() - startTime;
       debugLog(`[stream] Error after ${elapsed}ms: ${error.message}`);
-      const conv2 = queries.getConversation(conversationId);
-      if (conv2?.claudeSessionId) ownedSessionIds.delete(conv2.claudeSessionId);
       if (rateLimitState.get(conversationId)?.isStreamDetected) {
         debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping catch handler`);
         return;
@@ -79,7 +76,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);
-        batcher.drain();
         activeExecutions.delete(conversationId);
         return;
       }
@@ -98,7 +94,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() });
-        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`);
@@ -108,14 +103,13 @@ export function createProcessMessage({ queries, activeExecutions, rateLimitState
         }, cooldownMs);
         return;
       }
-      const isSessionConflict = error.exitCode === null && batcherRef.eventCount === 0;
+      const isSessionConflict = error.exitCode === null && stateRef.eventCount === 0;
       broadcastSync({ type: 'streaming_error', sessionId, conversationId, error: error.message, isPrematureEnd: error.isPrematureEnd || false, exitCode: error.exitCode, stderrText: error.stderrText, recoverable: elapsed < 60000, isSessionConflict, timestamp: Date.now() });
       if (!isSessionConflict) {
         const errMsg = queries.createMessage(conversationId, 'assistant', `Error: ${error.message}`);
         broadcastSync({ type: 'message_created', conversationId, message: errMsg, timestamp: Date.now() });
       }
     } finally {
-      batcher.drain();
       if (!rateLimitState.has(conversationId)) {
         cleanupExecution(conversationId);
         drainMessageQueue(conversationId);

package/lib/server-startup.js

@@ -1,6 +1,6 @@
 import { JsonlWatcher } from './jsonl-watcher.js';
 
-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 }) {
   let jsonlWatcher = null;
 
   function getJsonlWatcher() { return jsonlWatcher; }
@@ -23,8 +23,9 @@ export function createOnServerReady({ queries, broadcastSync, warmAssetCache, st
     }, 6 * 60 * 60 * 1000);
 
     try {
-      jsonlWatcher = new JsonlWatcher({ broadcastSync, queries, ownedSessionIds });
+      jsonlWatcher = new JsonlWatcher({ broadcastSync, queries });
       jsonlWatcher.start();
+      if (setWatcher) setWatcher(jsonlWatcher);
       console.log('[JSONL] Watcher started');
     } catch (err) { console.error('[JSONL] Watcher failed to start:', err.message); }
 

package/lib/stream-event-handler.js

@@ -1,40 +1,46 @@
-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.
+ *
+ * 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.
+ *
+ * No batcher, no broadcastSync for individual blocks.
+ */
+export function createEventHandler({ queries, activeExecutions, broadcastSync, rateLimitState, batcherRef, sessionId, conversationId, messageId, content, agentId, model, subAgent, getJsonlWatcher, scheduleRetry, eagerTTS, debugLog, parseRateLimitResetTime }) {
   return function onEvent(parsed) {
     batcherRef.eventCount++;
     const entry = activeExecutions.get(conversationId);
     if (entry) entry.lastActivity = Date.now();
+
+    // Register session with file watcher as soon as we see the session_id.
+    // This pre-maps claudeSessionId → (convId, dbSessionId) in JsonlParser before
+    // the 16ms file-watcher debounce fires, preventing duplicate conversation creation.
     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);
+        try { getJsonlWatcher()?.registerSession(parsed.session_id, conversationId, sessionId); } catch (_) {}
       }
     }
+
     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) {
+    // Rate-limit detection in assistant text blocks
+    if (parsed.type === 'assistant' && parsed.message?.content) {
       for (const block of parsed.message.content) {
-        allBlocksRef.val.push(block);
-        currentSequenceRef.val++;
-        batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, block.type || 'assistant', block);
-        broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block, blockRole: 'assistant', blockIndex: allBlocksRef.val.length - 1, seq: currentSequenceRef.val, timestamp: Date.now() });
         if (block.type === 'text' && block.text) {
           const rateLimitMatch = block.text.match(/you'?ve hit your limit|rate limit exceeded/i);
           if (rateLimitMatch) {
             debugLog(`[rate-limit] Detected rate limit message in stream for conv ${conversationId}`);
             const retryAfterSec = parseRateLimitResetTime(block.text);
             const entry2 = activeExecutions.get(conversationId);
-            if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (e) {} }
+            if (entry2 && entry2.pid) { try { process.kill(entry2.pid); } catch (_) {} }
             const existingCount = rateLimitState.get(conversationId)?.retryCount || 0;
             if (existingCount >= 3) {
-              batcherRef.batcher.drain();
               activeExecutions.delete(conversationId);
               queries.setIsStreaming(conversationId, false);
               const errMsg = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount + 1} attempts. Please try again later.`);
@@ -44,7 +50,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() });
-            batcherRef.batcher.drain();
             activeExecutions.delete(conversationId);
             queries.setIsStreaming(conversationId, false);
             setTimeout(() => {
@@ -57,59 +62,38 @@ export function createEventHandler({ queries, activeExecutions, broadcastSync, r
           eagerTTS(block.text, conversationId, sessionId);
         }
       }
-    } else if (parsed.type === 'user' && parsed.message?.content) {
-      for (const block of parsed.message.content) {
-        if (block.type === 'tool_result') {
-          const toolResultBlock = { type: 'tool_result', tool_use_id: block.tool_use_id, content: typeof block.content === 'string' ? block.content : JSON.stringify(block.content), is_error: block.is_error || false };
-          currentSequenceRef.val++;
-          batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'tool_result', toolResultBlock);
-          broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: toolResultBlock, blockRole: 'tool_result', blockIndex: allBlocksRef.val.length, seq: currentSequenceRef.val, timestamp: Date.now() });
-        }
-      }
-    } else if (parsed.type === 'result') {
-      const resultBlock = { type: 'result', subtype: parsed.subtype, duration_ms: parsed.duration_ms, total_cost_usd: parsed.total_cost_usd, num_turns: parsed.num_turns, is_error: parsed.is_error || false, result: parsed.result };
-      currentSequenceRef.val++;
-      batcherRef.batcher.add(sessionId, conversationId, currentSequenceRef.val, 'result', resultBlock);
-      broadcastSync({ type: 'streaming_progress', sessionId, conversationId, block: resultBlock, blockRole: 'result', blockIndex: allBlocksRef.val.length, isResult: true, seq: currentSequenceRef.val, timestamp: Date.now() });
-      if (parsed.result) {
-        const resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
-        const rlMatch = resultText.match(/you'?ve hit your limit|rate limit exceeded/i);
-        if (rlMatch) {
-          debugLog(`[rate-limit] Detected rate limit in result for conv ${conversationId}`);
-          const retryAfterSec = parseRateLimitResetTime(resultText);
-          const entry3 = activeExecutions.get(conversationId);
-          if (entry3 && entry3.pid) { try { process.kill(entry3.pid); } catch (e) {} }
-          const existingCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
-          if (existingCount2 >= 3) {
-            batcherRef.batcher.drain();
-            activeExecutions.delete(conversationId);
-            queries.setIsStreaming(conversationId, false);
-            const errMsg2 = queries.createMessage(conversationId, 'assistant', `Error: Rate limit exceeded after ${existingCount2 + 1} attempts. Please try again later.`);
-            broadcastSync({ type: 'message_created', conversationId, message: errMsg2, timestamp: Date.now() });
-            broadcastSync({ type: 'streaming_complete', sessionId, conversationId, interrupted: true, timestamp: Date.now() });
-            return;
-          }
-          rateLimitState.set(conversationId, { retryAt: Date.now() + (retryAfterSec * 1000), cooldownMs: retryAfterSec * 1000, retryCount: existingCount2 + 1, isStreamDetected: true });
-          broadcastSync({ type: 'rate_limit_hit', sessionId, conversationId, retryAfterMs: retryAfterSec * 1000, retryAt: Date.now() + (retryAfterSec * 1000), retryCount: existingCount2 + 1, timestamp: Date.now() });
-          batcherRef.batcher.drain();
+    }
+
+    // Rate-limit detection in result blocks
+    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);
+      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 (_) {} }
+        const existingCount2 = rateLimitState.get(conversationId)?.retryCount || 0;
+        if (existingCount2 >= 3) {
           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);
+          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;
         }
-        if (resultText) eagerTTS(resultText, conversationId, sessionId);
+        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() });
+        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 (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() });
+      if (resultText) eagerTTS(resultText, conversationId, sessionId);
     }
   };
 }

package/package.json

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

package/server.js

@@ -26,7 +26,7 @@ const sendWs = (ws, obj) => { if (ws.readyState === 1) ws.send(wsEncode(obj)); }
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-sdk-manager.js';
 import * as execMachine from './lib/execution-machine.js';
 import * as toolInstallMachine from './lib/tool-install-machine.js';
-import { _assetCache, htmlState, generateETag, warmAssetCache, serveFile as _serveFile, createChunkBatcher } from './lib/asset-server.js';
+import { _assetCache, htmlState, generateETag, warmAssetCache, serveFile as _serveFile } from './lib/asset-server.js';
 import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
 import * as toolManager from './lib/tool-manager.js';
 import { pm2Manager } from './lib/pm2-manager.js';
@@ -53,7 +53,7 @@ const activeExecutions = new Map();
 const activeScripts = new Map();
 const messageQueues = new Map();
 const rateLimitState = new Map();
-const ownedSessionIds = new Set();
+let _jsonlWatcher = null;
 const activeProcessesByRunId = new Map();
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 1800000;
@@ -121,8 +121,9 @@ const { scheduleRetry, drainMessageQueue } = createMessageQueue({ queries, messa
 const { processMessageWithStreaming } = createProcessMessage({
   queries, activeExecutions, rateLimitState, execMachine,
   broadcastSync, runClaudeWithStreaming, cleanupExecution, checkpointManager,
-  discoveredAgents, ownedSessionIds, STARTUP_CWD, buildSystemPrompt,
-  parseRateLimitResetTime, eagerTTS, touchACP, createChunkBatcher,
+  discoveredAgents, STARTUP_CWD, buildSystemPrompt,
+  parseRateLimitResetTime, eagerTTS, touchACP,
+  getJsonlWatcher: () => _jsonlWatcher,
   debugLog, logError,
   scheduleRetry, drainMessageQueue, createEventHandler
 });
@@ -187,7 +188,7 @@ setInterval(performDbRecovery, 300000);
 
 const { onServerReady, getJsonlWatcher } = createOnServerReady({
   queries, broadcastSync, warmAssetCache, staticDir, toolManager, discoveredAgents,
-  PORT, BASE_URL, watch, ownedSessionIds, resumeInterruptedStreams, activeExecutions,
+  PORT, BASE_URL, watch, setWatcher: (w) => { _jsonlWatcher = w; }, resumeInterruptedStreams, activeExecutions,
   debugLog, installGMAgentConfigs, startACPTools, getACPStatus, execMachine,
   toolInstallMachine, getSpeech, ensureModelsDownloaded, performAutoImport,
   performAgentHealthCheck, pm2Manager, pm2Subscribers, recoverStaleSessions