🤖 Use timestamp instead of boolean for pendingStreamStart

Replace boolean flag with timestamp to gracefully handle stale pending states.
Instead of a 30s timeout with timer cleanup, check if timestamp is recent (<3s)
when evaluating retry eligibility.

Benefits:
- No timer management/cleanup needed
- UI naturally re-evaluates on re-render
- More graceful - shows barrier after 3s if stream truly hung
- Handles edge cases (app restart, etc.) better

Changes:
- StreamingMessageAggregator: Store timestamp instead of bool, remove timer
- retryEligibility: Check if timestamp < 3s old to prevent flash
- WorkspaceStore: Expose pendingStreamStartTime instead of bool
- AIView/useResumeManager: Pass timestamp to hasInterruptedStream
- Tests: Updated to verify timestamp-based logic (11 tests passing)

Author: ammar-agent

src/components/AIView.tsx

@@ -212,7 +212,7 @@ const AIViewInner: React.FC<AIViewProps> = ({
     canInterrupt: workspaceState?.canInterrupt ?? false,
     showRetryBarrier: workspaceState
       ? !workspaceState.canInterrupt &&
-        hasInterruptedStream(workspaceState.messages, workspaceState.pendingStreamStart)
+        hasInterruptedStream(workspaceState.messages, workspaceState.pendingStreamStartTime)
       : false,
     currentWorkspaceThinking,
     setThinkingLevel,
@@ -261,15 +261,15 @@ const AIViewInner: React.FC<AIViewProps> = ({
   }
 
   // Extract state from workspace state
-  const { messages, canInterrupt, isCompacting, loading, currentModel, pendingStreamStart } =
+  const { messages, canInterrupt, isCompacting, loading, currentModel, pendingStreamStartTime } =
     workspaceState;
 
   // Get active stream message ID for token counting
   const activeStreamMessageId = aggregator.getActiveStreamMessageId();
 
   // Track if last message was interrupted or errored (for RetryBarrier)
   // Uses same logic as useResumeManager for DRY
-  const showRetryBarrier = !canInterrupt && hasInterruptedStream(messages, pendingStreamStart);
+  const showRetryBarrier = !canInterrupt && hasInterruptedStream(messages, pendingStreamStartTime);
 
   // Note: We intentionally do NOT reset autoRetry when streams start.
   // If user pressed Ctrl+C, autoRetry stays false until they manually retry.

src/hooks/useResumeManager.ts

@@ -95,7 +95,7 @@ export function useResumeManager() {
     // 1. Must have interrupted stream (not currently streaming)
     if (state.canInterrupt) return false; // Currently streaming
 
-    if (!hasInterruptedStream(state.messages, state.pendingStreamStart)) {
+    if (!hasInterruptedStream(state.messages, state.pendingStreamStartTime)) {
       return false;
     }
 

src/stores/WorkspaceStore.ts

@@ -28,7 +28,7 @@ export interface WorkspaceState {
   currentModel: string | null;
   recencyTimestamp: number | null;
   todos: TodoItem[];
-  pendingStreamStart: boolean;
+  pendingStreamStartTime: number | null;
 }
 
 /**
@@ -346,7 +346,7 @@ export class WorkspaceStore {
         currentModel: aggregator.getCurrentModel() ?? null,
         recencyTimestamp: aggregator.getRecencyTimestamp(),
         todos: aggregator.getCurrentTodos(),
-        pendingStreamStart: aggregator.isPendingStreamStart(),
+        pendingStreamStartTime: aggregator.getPendingStreamStartTime(),
       };
     });
   }

src/utils/messages/StreamingMessageAggregator.ts

@@ -62,8 +62,8 @@ export class StreamingMessageAggregator {
 
   // Track when we're waiting for stream-start after user message
   // Prevents retry barrier flash during normal send flow
-  private pendingStreamStart = false;
-  private pendingStreamStartTimer: ReturnType<typeof setTimeout> | null = null;
+  // Stores timestamp of when user message was sent (null = no pending stream)
+  private pendingStreamStartTime: number | null = null;
 
   // Workspace creation timestamp (used for recency calculation)
   private readonly createdAt?: string;
@@ -189,27 +189,12 @@ export class StreamingMessageAggregator {
     return this.messages.size > 0;
   }
 
-  isPendingStreamStart(): boolean {
-    return this.pendingStreamStart;
+  getPendingStreamStartTime(): number | null {
+    return this.pendingStreamStartTime;
   }
 
-  private setPendingStreamStart(pending: boolean): void {
-    // Clear existing timer if any
-    if (this.pendingStreamStartTimer) {
-      clearTimeout(this.pendingStreamStartTimer);
-      this.pendingStreamStartTimer = null;
-    }
-
-    this.pendingStreamStart = pending;
-
-    if (pending) {
-      // Set 30s timeout - if stream hasn't started by then, something is wrong
-      this.pendingStreamStartTimer = setTimeout(() => {
-        this.pendingStreamStart = false;
-        this.pendingStreamStartTimer = null;
-        this.invalidateCache(); // Trigger re-render to show retry barrier
-      }, 30000);
-    }
+  private setPendingStreamStartTime(time: number | null): void {
+    this.pendingStreamStartTime = time;
   }
 
   getActiveStreams(): StreamingContext[] {
@@ -282,8 +267,8 @@ export class StreamingMessageAggregator {
 
   // Unified event handlers that encapsulate all complex logic
   handleStreamStart(data: StreamStartEvent): void {
-    // Clear pending stream start flag - stream has started
-    this.setPendingStreamStart(false);
+    // Clear pending stream start timestamp - stream has started
+    this.setPendingStreamStartTime(null);
 
     // Detect if this stream is compacting by checking if last user message is a compaction-request
     const messages = this.getAllMessages();
@@ -606,9 +591,9 @@ export class StreamingMessageAggregator {
       // Now add the new message
       this.addMessage(incomingMessage);
 
-      // If this is a user message, set pendingStreamStart flag and start timeout
+      // If this is a user message, record timestamp for pending stream detection
       if (incomingMessage.role === "user") {
-        this.setPendingStreamStart(true);
+        this.setPendingStreamStartTime(Date.now());
       }
     }
   }

src/utils/messages/retryEligibility.test.ts

@@ -157,10 +157,10 @@ describe("hasInterruptedStream", () => {
         historySequence: 3,
       },
     ];
-    expect(hasInterruptedStream(messages, false)).toBe(true);
+    expect(hasInterruptedStream(messages, null)).toBe(true);
   });
 
-  it("returns false when pendingStreamStart is true", () => {
+  it("returns false when message was sent very recently (< 3s)", () => {
     const messages: DisplayedMessage[] = [
       {
         type: "user",
@@ -189,7 +189,9 @@ describe("hasInterruptedStream", () => {
         historySequence: 3,
       },
     ];
-    expect(hasInterruptedStream(messages, true)).toBe(false);
+    // Message sent 1 second ago - still within 3s window
+    const recentTimestamp = Date.now() - 1000;
+    expect(hasInterruptedStream(messages, recentTimestamp)).toBe(false);
   });
 
   it("returns true when user message has no response (slow model scenario)", () => {
@@ -202,10 +204,10 @@ describe("hasInterruptedStream", () => {
         historySequence: 1,
       },
     ];
-    expect(hasInterruptedStream(messages, false)).toBe(true);
+    expect(hasInterruptedStream(messages, null)).toBe(true);
   });
 
-  it("returns false when user message just sent and pendingStreamStart is true", () => {
+  it("returns false when user message just sent (< 3s ago)", () => {
     const messages: DisplayedMessage[] = [
       {
         type: "user",
@@ -215,6 +217,21 @@ describe("hasInterruptedStream", () => {
         historySequence: 1,
       },
     ];
-    expect(hasInterruptedStream(messages, true)).toBe(false);
+    const justSent = Date.now() - 500; // 0.5s ago
+    expect(hasInterruptedStream(messages, justSent)).toBe(false);
+  });
+
+  it("returns true when message sent over 3s ago (stream likely hung)", () => {
+    const messages: DisplayedMessage[] = [
+      {
+        type: "user",
+        id: "user-1",
+        historyId: "user-1",
+        content: "Hello",
+        historySequence: 1,
+      },
+    ];
+    const longAgo = Date.now() - 4000; // 4s ago - past 3s threshold
+    expect(hasInterruptedStream(messages, longAgo)).toBe(true);
   });
 });

src/utils/messages/retryEligibility.ts

@@ -15,17 +15,21 @@ import type { DisplayedMessage } from "@/types/message";
  * 3. Last message is a user message (indicating we sent it but never got a response)
  *    - This handles app restarts during slow model responses (models can take 30-60s to first token)
  *    - User messages are only at the end when response hasn't started/completed
- *    - EXCEPT: Not if pendingStreamStart is true (waiting for stream-start event)
+ *    - EXCEPT: Not if recently sent (<3s ago) - prevents flash during normal send flow
  */
 export function hasInterruptedStream(
   messages: DisplayedMessage[],
-  pendingStreamStart = false
+  pendingStreamStartTime: number | null = null
 ): boolean {
   if (messages.length === 0) return false;
 
-  // Don't show retry barrier if we're waiting for stream-start
-  // This prevents flash during normal send flow
-  if (pendingStreamStart) return false;
+  // Don't show retry barrier if user message was sent very recently (< 3s)
+  // This prevents flash during normal send flow while stream-start event arrives
+  // After 3s, we assume something is wrong and show the barrier
+  if (pendingStreamStartTime !== null) {
+    const elapsed = Date.now() - pendingStreamStartTime;
+    if (elapsed < 3000) return false;
+  }
 
   const lastMessage = messages[messages.length - 1];