fix: loadingOlder timeout + evidence-based stream retry reset

- useTimeline: 10s timeout on older-history requests — auto-resets
  loadingOlder if response never arrives (packet loss, disconnect)
- useTimeline: reset loadingOlder on WS disconnected event
- useTimeline: consolidate older state cleanup into resetOlderState()
- ws-client: retryCount now resets only when data actually flows
  (confirmStreamRecovery on raw frame), not on resubscribe attempt

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: IM.codes

web/src/hooks/useTimeline.ts

@@ -68,19 +68,15 @@ export function useTimeline(
     if (!sessionId) {
       setEvents([]);
       setLoading(false);
-      setLoadingOlder(false);
-      loadingOlderRef.current = false;
-      olderRequestIdRef.current = null;
+      resetOlderState();
       epochRef.current = 0;
       seqRef.current = 0;
       historyLoadedRef.current = null;
       return;
     }
 
     setRefreshing(false);
-    setLoadingOlder(false);
-    loadingOlderRef.current = false;
-    olderRequestIdRef.current = null;
+    resetOlderState();
     historyLoadedRef.current = null;
 
     let cancelled = false;
@@ -165,15 +161,26 @@ export function useTimeline(
     });
   }, [sessionId]);
 
+  const olderTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const resetOlderState = useCallback(() => {
+    loadingOlderRef.current = false;
+    olderRequestIdRef.current = null;
+    if (olderTimeoutRef.current) { clearTimeout(olderTimeoutRef.current); olderTimeoutRef.current = null; }
+    setLoadingOlder(false);
+  }, []);
+
   // Load older events (backward pagination)
   const loadOlderEvents = useCallback(() => {
     if (!ws?.connected || !sessionId || loadingOlderRef.current) return;
     const cached = eventsCache.get(sessionId);
     if (!cached || cached.length === 0) return;
     const oldestTs = Math.min(...cached.map((e) => e.ts));
-    loadingOlderRef.current = true; // Synchronous guard — prevents duplicate requests from rapid clicks
+    loadingOlderRef.current = true;
     setLoadingOlder(true);
     olderRequestIdRef.current = ws.sendTimelineHistoryRequest(sessionId, 500, undefined, oldestTs);
+    // Timeout: if response never arrives (packet loss, disconnect), reset after 10s
+    if (olderTimeoutRef.current) clearTimeout(olderTimeoutRef.current);
+    olderTimeoutRef.current = setTimeout(resetOlderState, 10_000);
   }, [ws, sessionId, loadingOlder]);
 
   // Append a single event, dedup by eventId
@@ -273,13 +280,11 @@ export function useTimeline(
 
         // Handle backward pagination response
         if (msg.requestId && msg.requestId === olderRequestIdRef.current) {
-          olderRequestIdRef.current = null;
-          loadingOlderRef.current = false;
+          resetOlderState();
           if (msg.events.length > 0) {
             mergeEvents(msg.events);
             sharedDb?.putEvents(msg.events).catch(() => {});
           }
-          setLoadingOlder(false);
           return;
         }
 
@@ -331,6 +336,10 @@ export function useTimeline(
           historyRequestIdRef.current = ws.sendTimelineHistoryRequest(sessionId, 500, afterTs);
         }
       }
+      // ── Browser WS disconnected: reset in-flight pagination to prevent stuck state ──
+      if (msg.type === 'session.event' && (msg as { event: string }).event === 'disconnected') {
+        if (loadingOlderRef.current) resetOlderState();
+      }
       // ── Browser WS reconnected: fill gaps since last seen seq ──
       if (msg.type === 'session.event' && (msg as { event: string }).event === 'connected') {
         if (ws && sessionId && epochRef.current > 0) {

web/src/ws-client.ts

@@ -419,9 +419,19 @@ export class WsClient {
     if (data.length < 3 + nameLen) return;
     const sessionName = new TextDecoder().decode(data.slice(3, 3 + nameLen));
     const ptyData = data.slice(3 + nameLen);
+    // Data flowing → stream recovered. Reset retry counter so future resets get full budget.
+    this.confirmStreamRecovery(sessionName);
     this._terminalRawHandlers.get(sessionName)?.forEach((h) => h(ptyData));
   }
 
+  /** Called when data arrives for a session — confirms stream is healthy, resets retry budget. */
+  private confirmStreamRecovery(session: string): void {
+    const state = this.resetState.get(session);
+    if (state && state.retryCount > 0) {
+      state.retryCount = 0;
+    }
+  }
+
   /**
    * Handle terminal.stream_reset: schedule resubscribe with exponential backoff.
    * Cooldown: 3+ resets within 60s → 30s pause before retrying.
@@ -468,10 +478,9 @@ export class WsClient {
     if (state.retryTimer) clearTimeout(state.retryTimer);
     state.retryTimer = setTimeout(() => {
       const s = this.resetState.get(session);
-      if (s) {
-        s.retryTimer = null;
-        s.retryCount = 0; // Reset on resubscribe — next reset starts fresh
-      }
+      if (s) s.retryTimer = null;
+      // retryCount is NOT reset here — only reset when data actually flows
+      // (confirmStreamRecovery called from handleRawFrame on first received frame)
       if (!this._destroyed && this._connected) {
         this.subscribeTerminal(session);
       }