agentgui 1.0.632 → 1.0.634

package/lib/claude-runner.js

@@ -49,6 +49,7 @@ class AgentRunner {
     this.buildArgs = config.buildArgs || this.defaultBuildArgs;
     this.parseOutput = config.parseOutput || this.defaultParseOutput;
     this.supportsStdin = config.supportsStdin ?? true;
+    this.closeStdin = config.closeStdin ?? false; // close stdin so process doesn't block waiting for input
     this.supportedFeatures = config.supportedFeatures || [];
     this.protocolHandler = config.protocolHandler || null;
     this.requiresAdapter = config.requiresAdapter || false;
@@ -91,7 +92,11 @@ class AgentRunner {
       if (Object.keys(this.spawnEnv).length > 0) {
         spawnOpts.env = { ...spawnOpts.env, ...this.spawnEnv };
       }
+      if (this.closeStdin) {
+        spawnOpts.stdio = ['ignore', 'pipe', 'pipe'];
+      }
       const proc = spawn(this.command, args, spawnOpts);
+      console.log(`[${this.id}] Spawned PID ${proc.pid} closeStdin=${this.closeStdin}`);
 
       if (config.onPid) {
         try { config.onPid(proc.pid); } catch (e) {}
@@ -116,15 +121,14 @@ class AgentRunner {
         reject(new Error(`${this.name} timeout after ${timeout}ms`));
       }, timeout);
 
-      // Write to stdin if supported
-      // Don't close stdin - keep it open for steering/injection during execution
+      // Write prompt to stdin if agent uses stdin protocol (not positional args)
       if (this.supportsStdin) {
         proc.stdin.write(prompt);
-        // Don't call stdin.end() - agents need open stdin for session/prompt steering
+        // Don't call stdin.end() - agents need open stdin for steering
       }
 
       proc.stdout.on('error', () => {});
-      proc.stderr.on('error', () => {});
+      if (proc.stderr) proc.stderr.on('error', () => {});
       proc.stdout.on('data', (chunk) => {
         if (timedOut) return;
 
@@ -152,7 +156,7 @@ class AgentRunner {
         }
       });
 
-      proc.stderr.on('data', (chunk) => {
+      if (proc.stderr) proc.stderr.on('data', (chunk) => {
         const errorText = chunk.toString();
         console.error(`[${this.id}] stderr:`, errorText);
 
@@ -605,9 +609,11 @@ registry.register({
   name: 'Claude Code',
   command: 'claude',
   protocol: 'direct',
-  supportsStdin: true,
+  supportsStdin: false,
+  closeStdin: true, // must close stdin or claude 2.1.72 hangs waiting for input in --print mode
+  useJsonRpcStdin: false,
   supportedFeatures: ['streaming', 'resume', 'system-prompt', 'permissions-skip'],
-  spawnEnv: { MAX_THINKING_TOKENS: '0' },
+  spawnEnv: { MAX_THINKING_TOKENS: '0', AGENTGUI_SUBPROCESS: '1' },
 
   buildArgs(prompt, config) {
     const {
@@ -627,6 +633,8 @@ registry.register({
     if (model) flags.push('--model', model);
     if (resumeSessionId) flags.push('--resume', resumeSessionId);
     if (systemPrompt) flags.push('--append-system-prompt', systemPrompt);
+    // Pass prompt as positional arg (works with claude 2.1.72+)
+    flags.push(prompt);
 
     return flags;
   },

package/lib/ws-optimizer.js

@@ -1,4 +1,4 @@
-import zlib from 'zlib';
+import { pack } from 'msgpackr';
 
 const MESSAGE_PRIORITY = {
   high: ['streaming_error', 'streaming_complete', 'rate_limit_hit', 'streaming_cancelled', 'run_cancelled', 'tool_install_complete', 'tool_update_complete', 'tool_install_failed', 'tool_update_failed'],
@@ -33,19 +33,21 @@ class ClientQueue {
     this.normalPriority = [];
     this.lowPriority = [];
     this.timer = null;
-    this.lastMessage = null;
+    this.lastKey = null;
     this.messageCount = 0;
     this.bytesSent = 0;
     this.windowStart = Date.now();
     this.rateLimitWarned = false;
   }
 
-  add(data, priority) {
-    if (this.lastMessage === data) return;
-    this.lastMessage = data;
-    if (priority === 3) this.highPriority.push(data);
-    else if (priority === 2) this.normalPriority.push(data);
-    else this.lowPriority.push(data);
+  add(event, priority) {
+    // Deduplicate by type+seq key
+    const key = event.type + (event.seq ?? '') + (event.sessionId ?? '');
+    if (this.lastKey === key) return;
+    this.lastKey = key;
+    if (priority === 3) this.highPriority.push(event);
+    else if (priority === 2) this.normalPriority.push(event);
+    else this.lowPriority.push(event);
     if (priority === 3) this.flushImmediate();
     else if (!this.timer) this.scheduleFlush();
   }
@@ -82,20 +84,12 @@ class ClientQueue {
       if (allowedCount <= 0) { this.scheduleFlush(); return; }
       batch.splice(allowedCount);
     }
-    let payload = batch.length === 1 ? batch[0] : '[' + batch.join(',') + ']';
-    if (payload.length > 1024) {
-      try {
-        const compressed = zlib.gzipSync(Buffer.from(payload), { level: 6 });
-        if (compressed.length < payload.length * 0.9) {
-          this.ws.send(JSON.stringify({ type: '_compressed', encoding: 'gzip' }));
-          this.ws.send(compressed);
-          payload = null;
-        }
-      } catch (e) {}
-    }
-    if (payload) this.ws.send(payload);
+    // Pack as msgpackr binary — perMessageDeflate on the WS server handles gzip
+    const envelope = batch.length === 1 ? batch[0] : batch;
+    const binary = pack(envelope);
+    this.ws.send(binary);
     this.messageCount += batch.length;
-    this.bytesSent += (payload ? payload.length : 0);
+    this.bytesSent += binary.length;
     if (windowDuration >= 3000 && this.bytesSent > 3 * 1024 * 1024) {
       const mbps = (this.bytesSent / windowDuration * 1000 / 1024 / 1024).toFixed(2);
       console.warn(`[ws-optimizer] Client ${this.ws.clientId} high bandwidth: ${mbps} MB/sec`);
@@ -116,16 +110,16 @@ class WSOptimizer {
     this.clientQueues = new Map();
   }
 
-  sendToClient(ws, event, originalType) {
+  sendToClient(ws, event) {
     if (ws.readyState !== 1) return;
     let queue = this.clientQueues.get(ws);
     if (!queue) {
       queue = new ClientQueue(ws);
       this.clientQueues.set(ws, queue);
     }
-    const data = typeof event === 'string' ? event : JSON.stringify(event);
-    const priority = typeof event === 'object' ? getPriority(originalType || event.type) : 2;
-    queue.add(data, priority);
+    const obj = typeof event === 'string' ? JSON.parse(event) : event;
+    const priority = getPriority(obj.type);
+    queue.add(obj, priority);
   }
 
   removeClient(ws) {

package/lib/ws-protocol.js

@@ -1,3 +1,9 @@
+import { pack, unpack } from 'msgpackr';
+
+function sendBinary(ws, obj) {
+  if (ws.readyState === 1) ws.send(pack(obj));
+}
+
 class WsRouter {
   constructor() {
     this.handlers = new Map();
@@ -15,25 +21,19 @@ class WsRouter {
   }
 
   reply(ws, requestId, data) {
-    if (ws.readyState === 1) {
-      ws.send(JSON.stringify({ r: requestId, d: data || {} }));
-    }
+    sendBinary(ws, { r: requestId, d: data || {} });
   }
 
   replyError(ws, requestId, code, message) {
-    if (ws.readyState === 1) {
-      ws.send(JSON.stringify({ r: requestId, e: { c: code, m: message } }));
-    }
+    sendBinary(ws, { r: requestId, e: { c: code, m: message } });
   }
 
   send(ws, type, data) {
-    if (ws.readyState === 1) {
-      ws.send(JSON.stringify({ t: type, d: data || {} }));
-    }
+    sendBinary(ws, { t: type, d: data || {} });
   }
 
   broadcast(clients, type, data) {
-    const msg = JSON.stringify({ t: type, d: data || {} });
+    const msg = pack({ t: type, d: data || {} });
     for (const ws of clients) {
       if (ws.readyState === 1) ws.send(msg);
     }
@@ -42,11 +42,14 @@ class WsRouter {
   async onMessage(ws, rawData) {
     let parsed;
     try {
-      parsed = JSON.parse(rawData);
-    } catch {
-      if (ws.readyState === 1) {
-        ws.send(JSON.stringify({ r: null, e: { c: 400, m: 'Invalid JSON' } }));
+      // Accept binary (msgpackr) or text (JSON fallback / legacy hot-reload)
+      if (Buffer.isBuffer(rawData) || rawData instanceof Uint8Array) {
+        parsed = unpack(rawData);
+      } else {
+        parsed = JSON.parse(rawData.toString());
       }
+    } catch {
+      sendBinary(ws, { r: null, e: { c: 400, m: 'Invalid message' } });
       return;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.632",
+  "version": "1.0.634",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -33,6 +33,7 @@
     "form-data": "^4.0.5",
     "fsbrowse": "^0.2.18",
     "google-auth-library": "^10.5.0",
+    "gpt-tokenizer": "^3.4.0",
     "msgpackr": "^1.11.8",
     "node-pty": "^1.0.0",
     "onnxruntime-node": "1.21.0",

package/static/index.html

@@ -3244,7 +3244,7 @@
   <script defer src="/gm/js/event-processor.js"></script>
   <script defer src="/gm/js/streaming-renderer.js"></script>
   <script defer src="/gm/js/image-loader.js"></script>
-  <script defer src="/gm/js/kalman-filter.js"></script>
+  <script src="/gm/lib/msgpackr.min.js"></script>
   <script defer src="/gm/js/event-consolidator.js"></script>
   <script defer src="/gm/js/websocket-manager.js"></script>
   <script defer src="/gm/js/ws-client.js"></script>

package/static/js/client.js

@@ -62,19 +62,6 @@ class AgentGUIClient {
     this._isLoadingConversation = false;
     this._modelCache = new Map();
 
-    this.chunkPollState = {
-      isPolling: false,
-      lastFetchTimestamp: 0,
-      pollTimer: null,
-      backoffDelay: 100,
-      maxBackoffDelay: 400,
-      abortController: null
-    };
-
-    this._pollIntervalByTier = {
-      excellent: 100, good: 200, fair: 400, poor: 800, bad: 1500, unknown: 200
-    };
-
     this._renderedSeqs = new Map();
     this._inflightRequests = new Map();
     this._previousConvAbort = null;
@@ -83,16 +70,10 @@ class AgentGUIClient {
     this._loadInProgress = {}; // { [conversationId]: { requestId, abortController, timestamp, prevConversationId } }
     this._currentRequestId = 0; // Auto-incrementing request counter
 
-    this._scrollKalman = typeof KalmanFilter !== 'undefined' ? new KalmanFilter({ processNoise: 50, measurementNoise: 100 }) : null;
     this._scrollTarget = 0;
     this._scrollAnimating = false;
     this._scrollLerpFactor = config.scrollAnimationSpeed || 0.15;
 
-    this._chunkTimingKalman = typeof KalmanFilter !== 'undefined' ? new KalmanFilter({ processNoise: 10, measurementNoise: 200 }) : null;
-    this._lastChunkArrival = 0;
-    this._chunkTimingUpdateCount = 0;
-    this._chunkMissedPredictions = 0;
-
     this._consolidator = typeof EventConsolidator !== 'undefined' ? new EventConsolidator() : null;
 
     this._serverProcessingEstimate = 2000;
@@ -603,7 +584,6 @@ class AgentGUIClient {
       this.state.currentConversation = null;
       this.state.currentSession = null;
       this.updateUrlForConversation(null);
-      this.stopChunkPolling();
       this.enableControls();
       this._showWelcomeScreen();
       if (this.ui.messageInput) {
@@ -936,26 +916,9 @@ class AgentGUIClient {
       this.scrollToBottom(true);
     }
 
-    // Immediately fetch any existing chunks for this session and start polling
-    // This ensures real-time feedback appears immediately
-    try {
-      const initialChunks = await this.fetchChunks(data.conversationId, 0);
-      // Filter to only chunks from the current session
-      const sessionChunks = initialChunks.filter(c => c.sessionId === data.sessionId && c.block && c.block.type);
-      if (sessionChunks.length > 0) {
-        this.renderChunkBatch(sessionChunks);
-        // Update lastFetchTimestamp so polling doesn't duplicate these chunks
-        const lastChunk = sessionChunks[sessionChunks.length - 1];
-        if (lastChunk && lastChunk.created_at) {
-          this.chunkPollState.lastFetchTimestamp = lastChunk.created_at;
-        }
-      }
-    } catch (e) {
-      console.warn('Initial chunk fetch failed:', e.message);
-    }
-
-    // Start polling for chunks from database
-    this.startChunkPolling(data.conversationId);
+    // Reset rendered block seq tracker for this session
+    this._renderedSeqs = this._renderedSeqs || {};
+    this._renderedSeqs[data.sessionId] = new Set();
 
     // Show queue/steer UI when streaming starts (for busy prompt)
     this.showStreamingPromptButtons();
@@ -978,30 +941,33 @@ class AgentGUIClient {
   }
 
   handleStreamingProgress(data) {
-    // NOTE: With chunk-based architecture, blocks are rendered from polling
-    // This handler is kept for backward compatibility and to trigger polling updates
-    // But actual rendering happens in renderChunk() via polling
+    if (!data.block || !data.sessionId) return;
 
-    if (!data.block) return;
+    // Deduplicate by seq number to guarantee exactly-once rendering
+    this._renderedSeqs = this._renderedSeqs || {};
+    const seen = this._renderedSeqs[data.sessionId] || (this._renderedSeqs[data.sessionId] = new Set());
+    if (data.seq !== undefined) {
+      if (seen.has(data.seq)) return;
+      seen.add(data.seq);
+    }
 
     const block = data.block;
     if (!this.state.streamingBlocks) this.state.streamingBlocks = [];
     this.state.streamingBlocks.push(block);
 
-    // Thinking blocks are transient and not stored in DB, so render immediately
-    if (block.type === 'thinking' && this.state.currentSession?.id === data.sessionId) {
-      const streamingEl = document.getElementById(`streaming-${data.sessionId}`);
-      if (streamingEl) {
-        const blocksEl = streamingEl.querySelector('.streaming-blocks');
-        if (blocksEl) {
-          const el = this.renderer.renderBlock(block, data, blocksEl);
-          if (el) blocksEl.appendChild(el);
-        }
-      }
-    }
+    // Only render for the currently-visible session
+    if (this.state.currentSession?.id !== data.sessionId) return;
 
-    // WebSocket is now just a notification trigger, not data source
-    // Actual blocks come from database polling in startChunkPolling()
+    const streamingEl = document.getElementById(`streaming-${data.sessionId}`);
+    if (!streamingEl) return;
+    const blocksEl = streamingEl.querySelector('.streaming-blocks');
+    if (!blocksEl) return;
+
+    const el = this.renderer.renderBlock(block, data, blocksEl);
+    if (el) {
+      blocksEl.appendChild(el);
+      this.scrollToBottom();
+    }
   }
 
   renderBlockContent(block) {
@@ -1102,9 +1068,6 @@ class AgentGUIClient {
     this.state.streamingConversations.delete(conversationId);
     this.updateBusyPromptArea(conversationId);
 
-    // Stop polling for chunks
-    this.stopChunkPolling();
-
     // Clear queue indicator on error
     const queueEl = document.querySelector('.queue-indicator');
     if (queueEl) queueEl.remove();
@@ -1154,7 +1117,7 @@ class AgentGUIClient {
     this.state.streamingConversations.delete(conversationId);
     this.updateBusyPromptArea(conversationId);
 
-    this.stopChunkPolling();
+
 
     // Clear queue indicator when streaming completes
     const queueEl = document.querySelector('.queue-indicator');
@@ -1182,13 +1145,10 @@ class AgentGUIClient {
       this.saveScrollPosition(conversationId);
     }
 
-    // Fetch any final chunks that may have been missed during polling
-    // This ensures all output is visible without requiring a page refresh
-    if (conversationId && sessionId) {
-      this.fetchRemainingChunks(conversationId, sessionId).catch(err => {
-        console.warn('Final chunk fetch failed:', err.message);
-      });
-    }
+    // Recover any blocks missed during streaming (e.g. WS reconnects)
+    this._recoverMissedChunks().catch(err => {
+      console.warn('Chunk recovery failed:', err.message);
+    });
 
     this.enableControls();
     this.emit('streaming:complete', data);
@@ -1368,7 +1328,7 @@ class AgentGUIClient {
   handleRateLimitHit(data) {
     if (data.conversationId !== this.state.currentConversation?.id) return;
     this.state.streamingConversations.delete(data.conversationId);
-    this.stopChunkPolling();
+
     this.enableControls();
 
     const cooldownMs = data.retryAfterMs || 60000;
@@ -1728,13 +1688,11 @@ class AgentGUIClient {
         block: typeof c.data === 'string' ? JSON.parse(c.data) : c.data
       })).filter(c => c.block && c.block.type);
 
-      const dedupedChunks = chunks.filter(c => {
-        const seqSet = this._renderedSeqs.get(sessionId);
-        return !seqSet || !seqSet.has(c.sequence);
-      });
+      const seenSeqs = (this._renderedSeqs || {})[sessionId];
+      const dedupedChunks = chunks.filter(c => !seenSeqs || !seenSeqs.has(c.sequence));
 
       if (dedupedChunks.length > 0) {
-        this.renderChunkBatch(dedupedChunks);
+        for (const chunk of dedupedChunks) this.renderChunk(chunk);
       }
     } catch (e) {
       console.warn('Chunk recovery failed:', e.message);
@@ -1752,46 +1710,6 @@ class AgentGUIClient {
     return promise;
   }
 
-  _getAdaptivePollInterval() {
-    const quality = this.wsManager?.latency?.quality || 'unknown';
-    const base = this._pollIntervalByTier[quality] || 200;
-    const trend = this.wsManager?.latency?.trend;
-    if (!trend || trend === 'stable') return base;
-    const tiers = ['excellent', 'good', 'fair', 'poor', 'bad'];
-    const idx = tiers.indexOf(quality);
-    if (trend === 'rising' && idx < tiers.length - 1) return this._pollIntervalByTier[tiers[idx + 1]];
-    if (trend === 'falling' && idx > 0) return this._pollIntervalByTier[tiers[idx - 1]];
-    return base;
-  }
-
-  _chunkArrivalConfidence() {
-    if (this._chunkTimingUpdateCount < 2) return 0;
-    const base = Math.min(1, this._chunkTimingUpdateCount / 8);
-    const penalty = Math.min(1, this._chunkMissedPredictions * 0.33);
-    return Math.max(0, base - penalty);
-  }
-
-  _predictedNextChunkArrival() {
-    if (!this._chunkTimingKalman || this._chunkTimingUpdateCount < 2) return 0;
-    return this._lastChunkArrival + Math.min(this._chunkTimingKalman.predict(), 5000);
-  }
-
-  _schedulePreAllocation(sessionId) {
-    if (this._placeholderTimer) clearTimeout(this._placeholderTimer);
-    if (this._chunkArrivalConfidence() < 0.5) return;
-    const scrollContainer = document.getElementById('output-scroll');
-    if (!scrollContainer) return;
-    const distFromBottom = scrollContainer.scrollHeight - scrollContainer.scrollTop - scrollContainer.clientHeight;
-    if (distFromBottom > 150) return;
-    const nextArrival = this._predictedNextChunkArrival();
-    if (!nextArrival) return;
-    const delay = Math.max(0, nextArrival - performance.now() - 100);
-    this._placeholderTimer = setTimeout(() => {
-      this._placeholderTimer = null;
-      this._insertPlaceholder(sessionId);
-    }, delay);
-  }
-
   _insertPlaceholder(sessionId) {
     this._removePlaceholder();
     const streamingEl = document.getElementById(`streaming-${sessionId}`);
@@ -1857,27 +1775,14 @@ class AgentGUIClient {
 
   _setupDebugHooks() {
     if (typeof window === 'undefined') return;
-    const kalmanHistory = { latency: [], scroll: [], chunkTiming: [] };
     const self = this;
-    window.__kalman = {
-      latency: this.wsManager?._latencyKalman || null,
-      scroll: this._scrollKalman || null,
-      chunkTiming: this._chunkTimingKalman || null,
-      history: kalmanHistory,
+    window.__debug = {
       getState: () => ({
-        latency: self.wsManager?._latencyKalman?.getState() || null,
-        scroll: self._scrollKalman?.getState() || null,
-        chunkTiming: self._chunkTimingKalman?.getState() || null,
+        latencyEma: self.wsManager?._latencyEma || null,
         serverProcessingEstimate: self._serverProcessingEstimate,
-        chunkConfidence: self._chunkArrivalConfidence(),
         latencyTrend: self.wsManager?.latency?.trend || null
       })
     };
-
-    this.wsManager.on('latency_prediction', (data) => {
-      kalmanHistory.latency.push({ time: Date.now(), ...data });
-      if (kalmanHistory.latency.length > 100) kalmanHistory.latency.shift();
-    });
   }
 
   /**
@@ -2006,174 +1911,6 @@ class AgentGUIClient {
     }
   }
 
-  /**
-   * Fetch chunks from database for a conversation
-   * Supports incremental updates with since parameter
-   */
-  async fetchChunks(conversationId, since = 0) {
-    if (!conversationId) return [];
-
-    try {
-      const data = await window.wsClient.rpc('conv.chunks', { id: conversationId, since: since > 0 ? since : 0 });
-      if (!data.ok || !Array.isArray(data.chunks)) {
-        throw new Error('Invalid chunks response');
-      }
-
-      const chunks = data.chunks.map(chunk => ({
-        ...chunk,
-        block: typeof chunk.data === 'string' ? JSON.parse(chunk.data) : chunk.data
-      }));
-
-      return chunks;
-    } catch (error) {
-      if (error.name === 'AbortError') return [];
-      console.error('Error fetching chunks:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Poll for new chunks at regular intervals
-   * Uses exponential backoff on errors
-   * Also checks session status to detect completion
-   */
-  async startChunkPolling(conversationId) {
-    if (!conversationId) return;
-
-    const pollState = this.chunkPollState;
-    if (pollState.isPolling) return;
-
-    pollState.isPolling = true;
-    // Only reset lastFetchTimestamp if it wasn't already set by initial fetch
-    if (pollState.lastFetchTimestamp === 0) {
-      pollState.lastFetchTimestamp = Date.now();
-    }
-    pollState.backoffDelay = this._getAdaptivePollInterval();
-    pollState.sessionCheckCounter = 0;
-    pollState.emptyPollCount = 0;
-
-    const checkSessionStatus = async () => {
-      if (!this.state.currentSession?.id) return false;
-      let session;
-      try { ({ session } = await window.wsClient.rpc('sess.get', { id: this.state.currentSession.id })); } catch { return false; }
-      if (session && (session.status === 'complete' || session.status === 'error')) {
-        if (session.status === 'complete') {
-          this.handleStreamingComplete({ sessionId: session.id, conversationId, timestamp: Date.now() });
-        } else {
-          this.handleStreamingError({ sessionId: session.id, conversationId, error: session.error || 'Unknown error', timestamp: Date.now() });
-        }
-        return true;
-      }
-      return false;
-    };
-
-    const pollOnce = async () => {
-      if (!pollState.isPolling) return;
-
-      try {
-        pollState.sessionCheckCounter++;
-        const shouldCheckSession = pollState.sessionCheckCounter % 3 === 0 || pollState.emptyPollCount >= 3;
-        if (shouldCheckSession) {
-          const done = await checkSessionStatus();
-          if (done) return;
-          if (pollState.emptyPollCount >= 3) pollState.emptyPollCount = 0;
-        }
-
-        const chunks = await this.fetchChunks(conversationId, pollState.lastFetchTimestamp);
-
-        if (chunks.length > 0) {
-          pollState.backoffDelay = this._getAdaptivePollInterval();
-          pollState.emptyPollCount = 0;
-          const lastChunk = chunks[chunks.length - 1];
-          pollState.lastFetchTimestamp = lastChunk.created_at;
-
-          const now = performance.now();
-          if (this._lastChunkArrival > 0 && this._chunkTimingKalman) {
-            const delta = now - this._lastChunkArrival;
-            this._chunkTimingKalman.update(delta);
-            this._chunkTimingUpdateCount++;
-            this._chunkMissedPredictions = 0;
-          }
-          this._lastChunkArrival = now;
-
-          this.renderChunkBatch(chunks.filter(c => c.block && c.block.type));
-          if (this.state.currentSession?.id) this._schedulePreAllocation(this.state.currentSession.id);
-        } else {
-          pollState.emptyPollCount++;
-          if (this._chunkTimingUpdateCount > 0) this._chunkMissedPredictions++;
-          pollState.backoffDelay = Math.min(pollState.backoffDelay + 50, 500);
-        }
-
-        if (pollState.isPolling) {
-          let nextDelay = pollState.backoffDelay;
-          if (this._chunkArrivalConfidence() >= 0.3 && this._chunkTimingKalman) {
-            const predicted = this._chunkTimingKalman.predict();
-            const elapsed = performance.now() - this._lastChunkArrival;
-            const untilNext = predicted - elapsed - 20;
-            nextDelay = Math.max(50, Math.min(2000, untilNext));
-            if (this._chunkMissedPredictions >= 3) {
-              this._chunkTimingKalman.setProcessNoise(20);
-            } else {
-              this._chunkTimingKalman.setProcessNoise(10);
-            }
-          }
-          pollState.pollTimer = setTimeout(pollOnce, nextDelay);
-        }
-      } catch (error) {
-        console.warn('Chunk poll error:', error.message);
-        pollState.backoffDelay = Math.min(pollState.backoffDelay * 2, pollState.maxBackoffDelay);
-        if (pollState.isPolling) {
-          pollState.pollTimer = setTimeout(pollOnce, pollState.backoffDelay);
-        }
-      }
-    };
-
-    pollOnce();
-  }
-
-  /**
-   * Stop polling for chunks
-   */
-  stopChunkPolling() {
-    const pollState = this.chunkPollState;
-
-    if (pollState.pollTimer) {
-      clearTimeout(pollState.pollTimer);
-      pollState.pollTimer = null;
-    }
-
-    if (pollState.abortController) {
-      pollState.abortController.abort();
-      pollState.abortController = null;
-    }
-
-    pollState.isPolling = false;
-    this._scrollAnimating = false;
-    if (this._scrollKalman) this._scrollKalman.reset();
-    if (this._chunkTimingKalman) this._chunkTimingKalman.reset();
-    this._chunkTimingUpdateCount = 0;
-    this._chunkMissedPredictions = 0;
-    this._lastChunkArrival = 0;
-    if (this._placeholderTimer) { clearTimeout(this._placeholderTimer); this._placeholderTimer = null; }
-  }
-
-  /**
-   * Fetch any remaining chunks after streaming completes
-   * Ensures all output is visible without requiring a page refresh
-   */
-  async fetchRemainingChunks(conversationId, sessionId) {
-    try {
-      const lastTimestamp = this.chunkPollState.lastFetchTimestamp || 0;
-      const chunks = await this.fetchChunks(conversationId, lastTimestamp);
-      const sessionChunks = chunks.filter(c => c.sessionId === sessionId && c.block && c.block.type);
-      if (sessionChunks.length > 0) {
-        this.renderChunkBatch(sessionChunks);
-      }
-    } catch (err) {
-      console.error('Failed to fetch remaining chunks:', err);
-    }
-  }
-
   /**
    * Render a single chunk to the output
    */
@@ -2203,71 +1940,6 @@ class AgentGUIClient {
     this.scrollToBottom();
   }
 
-  renderChunkBatch(chunks) {
-    if (!chunks.length) return;
-    const deduped = [];
-    for (const chunk of chunks) {
-      const sid = chunk.sessionId;
-      if (!this._renderedSeqs.has(sid)) this._renderedSeqs.set(sid, new Set());
-      const seqSet = this._renderedSeqs.get(sid);
-      if (chunk.sequence !== undefined && seqSet.has(chunk.sequence)) continue;
-      if (chunk.sequence !== undefined) seqSet.add(chunk.sequence);
-      deduped.push(chunk);
-    }
-    if (!deduped.length) return;
-
-    let toRender = deduped;
-    if (this._consolidator) {
-      const { consolidated, stats } = this._consolidator.consolidate(deduped);
-      toRender = consolidated;
-      for (const c of consolidated) {
-        if (c._mergedSequences) {
-          const seqSet = this._renderedSeqs.get(c.sessionId);
-          if (seqSet) c._mergedSequences.forEach(s => seqSet.add(s));
-        }
-      }
-      if (stats.textMerged || stats.toolsCollapsed || stats.systemSuperseded) {
-        console.log('Consolidation:', stats);
-      }
-    }
-
-    this._removePlaceholder();
-    const groups = {};
-    for (const chunk of toRender) {
-      const sid = chunk.sessionId;
-      if (!groups[sid]) groups[sid] = [];
-      groups[sid].push(chunk);
-    }
-    let appended = false;
-    for (const sid of Object.keys(groups)) {
-      const streamingEl = document.getElementById(`streaming-${sid}`);
-      if (!streamingEl) continue;
-      const blocksEl = streamingEl.querySelector('.streaming-blocks');
-      if (!blocksEl) continue;
-      for (const chunk of groups[sid]) {
-        if (chunk.block.type === 'tool_result') {
-          const matchById = chunk.block.tool_use_id && blocksEl.querySelector(`.block-tool-use[data-tool-use-id="${chunk.block.tool_use_id}"]`);
-          const lastEl = blocksEl.lastElementChild;
-          const toolUseEl = matchById || (lastEl?.classList?.contains('block-tool-use') ? lastEl : null);
-          if (toolUseEl) {
-            toolUseEl.classList.remove('has-success', 'has-error');
-            toolUseEl.classList.add(chunk.block.is_error ? 'has-error' : 'has-success');
-            const parentIsOpen = toolUseEl.hasAttribute('open');
-            const contextWithParent = { ...chunk, parentIsOpen };
-            const el = this.renderer.renderBlock(chunk.block, contextWithParent, blocksEl);
-            if (el) { toolUseEl.appendChild(el); appended = true; }
-            continue;
-          }
-        }
-        const el = this.renderer.renderBlock(chunk.block, chunk, blocksEl);
-        if (!el) { appended = true; continue; }
-        blocksEl.appendChild(el);
-        appended = true;
-      }
-    }
-    if (appended) this.scrollToBottom();
-  }
-
   /**
    * Load agents
    */
@@ -2744,7 +2416,7 @@ class AgentGUIClient {
       const prevConversationId = this.state.currentConversation?.id;
       const availableFallback = this.state.conversations?.find(c => c.id !== conversationId) || null;
       this.cacheCurrentConversation();
-      this.stopChunkPolling();
+  
       this.removeScrollUpDetection();
       if (this.renderer.resetScrollState) this.renderer.resetScrollState();
       this._userScrolledUp = false;
@@ -3031,12 +2703,6 @@ class AgentGUIClient {
 
           this.updateUrlForConversation(conversationId, latestSession.id);
 
-          const lastChunkTime = chunks.length > 0
-            ? chunks[chunks.length - 1].created_at
-            : 0;
-
-          this.chunkPollState.lastFetchTimestamp = lastChunkTime;
-          this.startChunkPolling(conversationId);
           // IMMUTABLE: Prompt remains enabled - syncPromptState will set correct state
           this.syncPromptState(conversationId);
         } else {
@@ -3421,7 +3087,7 @@ class AgentGUIClient {
    * Cleanup resources
    */
   destroy() {
-    this.stopChunkPolling();
+
     this.renderer.destroy();
     this.wsManager.destroy();
     this.eventHandlers = {};

package/static/js/websocket-manager.js

@@ -40,7 +40,7 @@ class WebSocketManager {
       pingCounter: 0
     };
 
-    this._latencyKalman = typeof KalmanFilter !== 'undefined' ? new KalmanFilter({ processNoise: 1, measurementNoise: 10 }) : null;
+    this._latencyEma = null; // exponential moving average for latency
     this._trendHistory = [];
     this._trendCount = 0;
     this._reconnectedAt = 0;
@@ -84,6 +84,7 @@ class WebSocketManager {
 
     try {
       this.ws = new WebSocket(this.config.url);
+      this.ws.binaryType = 'arraybuffer';
       this.ws.onopen = () => this.onOpen();
       this.ws.onmessage = (event) => this.onMessage(event);
       this.ws.onerror = (error) => this.onError(error);
@@ -129,9 +130,19 @@ class WebSocketManager {
     this.emit('connected', { timestamp: Date.now() });
   }
 
-  onMessage(event) {
+  async onMessage(event) {
     try {
-      const parsed = JSON.parse(event.data);
+      let parsed;
+      if (event.data instanceof Blob || event.data instanceof ArrayBuffer) {
+        // Binary frame: msgpackr-encoded (perMessageDeflate decompressed by browser)
+        const buf = event.data instanceof Blob
+          ? await event.data.arrayBuffer()
+          : event.data;
+        parsed = msgpackr.unpack(new Uint8Array(buf));
+      } else {
+        // Fallback: plain JSON (ping/pong control frames, legacy)
+        parsed = JSON.parse(event.data);
+      }
       const messages = Array.isArray(parsed) ? parsed : [parsed];
       this.stats.totalMessagesReceived += messages.length;
 
@@ -154,6 +165,11 @@ class WebSocketManager {
           );
         }
 
+        // RPC reply envelopes — emit for WsClient to intercept, then skip broadcast
+        if (data.r !== undefined && !data.type) {
+          this.emit('message', data);
+          continue;
+        }
         this.emit('message', data);
         if (data.type) this.emit('message:' + data.type, data);
       }
@@ -181,21 +197,12 @@ class WebSocketManager {
 
     this.latency.current = rtt;
 
-    if (this._latencyKalman && samples.length > 3) {
-      if (this._reconnectedAt && Date.now() - this._reconnectedAt < 5000) {
-        this._latencyKalman.setMeasurementNoise(50);
-      } else {
-        this._latencyKalman.setMeasurementNoise(10);
-      }
-      const result = this._latencyKalman.update(rtt);
-      this.latency.predicted = result.estimate;
-      this.latency.predictedNext = this._latencyKalman.predict();
-      this.latency.avg = result.estimate;
-    } else {
-      this.latency.avg = samples.reduce((a, b) => a + b, 0) / samples.length;
-      this.latency.predicted = this.latency.avg;
-      this.latency.predictedNext = this.latency.avg;
-    }
+    // EMA smoothing (α=0.2 → slow adaptation, less noise)
+    const alpha = 0.2;
+    this._latencyEma = this._latencyEma === null ? rtt : alpha * rtt + (1 - alpha) * this._latencyEma;
+    this.latency.avg = this._latencyEma;
+    this.latency.predicted = this._latencyEma;
+    this.latency.predictedNext = this._latencyEma;
 
     if (samples.length > 1) {
       const mean = samples.reduce((a, b) => a + b, 0) / samples.length;
@@ -233,7 +240,7 @@ class WebSocketManager {
       predicted: this.latency.predicted,
       predictedNext: this.latency.predictedNext,
       trend: this.latency.trend,
-      gain: this._latencyKalman ? this._latencyKalman.getState().gain : 0
+      gain: 0
     });
 
     this._checkDegradation();
@@ -370,8 +377,8 @@ class WebSocketManager {
       this._hiddenAt = Date.now();
       return;
     }
-    if (this._hiddenAt && this._latencyKalman && Date.now() - this._hiddenAt > 30000) {
-      this._latencyKalman.reset();
+    if (this._hiddenAt && Date.now() - this._hiddenAt > 30000) {
+      this._latencyEma = null;
       this._trendHistory = [];
       this.latency.trend = 'stable';
     }
@@ -436,7 +443,7 @@ class WebSocketManager {
     }
 
     try {
-      this.ws.send(JSON.stringify(data));
+      this.ws.send(msgpackr.pack(data));
       this.stats.totalMessagesSent++;
       return true;
     } catch (error) {
@@ -460,7 +467,7 @@ class WebSocketManager {
     this.messageBuffer = [];
     for (const message of messages) {
       try {
-        this.ws.send(JSON.stringify(message));
+        this.ws.send(msgpackr.pack(message));
         this.stats.totalMessagesSent++;
       } catch (error) {
         this.bufferMessage(message);
@@ -484,7 +491,7 @@ class WebSocketManager {
       if (type === 'session') msg.sessionId = id;
       else msg.conversationId = id;
       try {
-        this.ws.send(JSON.stringify(msg));
+        this.ws.send(msgpackr.pack(msg));
         this.stats.totalMessagesSent++;
       } catch (_) {}
     }

package/static/js/ws-client.js

@@ -10,36 +10,21 @@ class WsClient {
   _install() {
     if (this._installed) return;
     this._installed = true;
-    const origOnMessage = this._ws.onMessage.bind(this._ws);
-    this._ws.onMessage = (event) => {
-      try {
-        const parsed = JSON.parse(event.data);
-        const messages = Array.isArray(parsed) ? parsed : [parsed];
-        const passthrough = [];
-        for (const msg of messages) {
-          if (msg.r && this._pending.has(msg.r)) {
-            const p = this._pending.get(msg.r);
-            this._pending.delete(msg.r);
-            clearTimeout(p.timer);
-            if (msg.e) {
-              p.reject(Object.assign(new Error(msg.e.m || 'RPC error'), { code: msg.e.c }));
-            } else {
-              p.resolve(msg.d);
-            }
-          } else {
-            passthrough.push(msg);
-          }
+    // Listen on decoded message objects — websocket-manager emits 'message' with decoded obj
+    this._ws.on('message', (data) => {
+      if (data.r && this._pending.has(data.r)) {
+        const p = this._pending.get(data.r);
+        this._pending.delete(data.r);
+        clearTimeout(p.timer);
+        if (data.e) {
+          p.reject(Object.assign(new Error(data.e.m || 'RPC error'), { code: data.e.c }));
+        } else {
+          p.resolve(data.d);
         }
-        if (passthrough.length > 0) {
-          const rebuilt = passthrough.length === 1
-            ? JSON.stringify(passthrough[0])
-            : JSON.stringify(passthrough);
-          origOnMessage({ data: rebuilt });
-        }
-      } catch (_) {
-        origOnMessage(event);
+        return; // consumed — don't re-emit
       }
-    };
+      // Non-RPC messages are already emitted by websocket-manager; nothing to do
+    });
     this._ws.on('disconnected', () => this.cancelAll());
   }
 
@@ -79,7 +64,7 @@ class WsClient {
   }
 
   cancelAll() {
-    for (const [id, p] of this._pending) {
+    for (const [, p] of this._pending) {
       clearTimeout(p.timer);
       p.reject(new Error('Connection lost'));
     }

package/static/js/kalman-filter.js

@@ -1,67 +0,0 @@
-class KalmanFilter {
-  constructor(config = {}) {
-    this._initEst = config.initialEstimate || 0;
-    this._initErr = config.initialError || 1000;
-    this._q = Math.max(config.processNoise || 1, 0.001);
-    this._r = config.measurementNoise || 10;
-    this._est = this._initEst;
-    this._err = this._initErr;
-    this._gain = 0;
-    this._initialized = false;
-    this._lastValid = this._initEst;
-  }
-
-  update(measurement) {
-    if (!Number.isFinite(measurement)) {
-      return { estimate: this._est, error: this._err, gain: this._gain };
-    }
-    if (measurement < 0) measurement = 0;
-    if (!this._initialized) {
-      this._est = measurement;
-      this._err = this._r;
-      this._initialized = true;
-      this._lastValid = measurement;
-      this._gain = 1;
-      return { estimate: this._est, error: this._err, gain: this._gain };
-    }
-    let r = this._r;
-    if (this._est > 0 && Math.abs(measurement - this._est) > this._est * 10) {
-      r = r * 100;
-    }
-    const predErr = this._err + this._q;
-    this._gain = predErr / (predErr + r);
-    this._est = this._est + this._gain * (measurement - this._est);
-    this._err = (1 - this._gain) * predErr;
-    if (this._err < 1e-10) this._err = 1e-10;
-    this._lastValid = this._est;
-    return { estimate: this._est, error: this._err, gain: this._gain };
-  }
-
-  predict() {
-    return this._est;
-  }
-
-  setProcessNoise(q) { this._q = Math.max(q, 0.001); }
-  setMeasurementNoise(r) { this._r = r; }
-
-  getState() {
-    return {
-      estimate: this._est,
-      error: this._err,
-      gain: this._gain,
-      processNoise: this._q,
-      measurementNoise: this._r,
-      initialized: this._initialized
-    };
-  }
-
-  reset() {
-    this._est = this._initEst;
-    this._err = this._initErr;
-    this._gain = 0;
-    this._initialized = false;
-    this._lastValid = this._initEst;
-  }
-}
-
-if (typeof module !== 'undefined' && module.exports) module.exports = KalmanFilter;