🤖 Replace time-based hack with explicit pendingStreamStart tracking

The original fix used time-based hacks (checking message age, forced
re-renders with timers) to prevent retry barrier flash. This was janky
and semantically incorrect.

New approach:
- Track pendingStreamStart flag in StreamingMessageAggregator
- Set true when user message is received
- Set false when stream-start arrives
- 30s timeout if stream never starts (safety net)
- hasInterruptedStream() checks this flag instead of message age

Benefits:
- Semantically correct: explicitly tracks "waiting for stream-start"
- No frontend timer hacks - state updates drive UI naturally
- Cleaner: removed ~24 LoC of hacky code, added ~60 LoC of proper state
- The 30s timeout is meaningful (truly stuck) vs arbitrary ("hide for 2s")

Changes:
- StreamingMessageAggregator: +25 LoC (flag, timer, handlers)
- WorkspaceStore: +3 LoC (expose via state)
- retryEligibility: -14 LoC (removed time checks, added flag param)
- AIView: -27 LoC (removed timer hack)
- Tests: Updated to use flag instead of timestamps

Net: +40 LoC but much cleaner architecture.

Author: ammar-agent

src/components/AIView.tsx

@@ -52,9 +52,6 @@ const AIViewInner: React.FC<AIViewProps> = ({
   const [activeTab, setActiveTab] = useState<TabType>("costs");
   const isReviewTabActive = activeTab === "review";
 
-  // Force re-check state for retry barrier (incremented to trigger re-evaluation)
-  const [, setForceRecheck] = useState(0);
-
   // Resizable sidebar for Review tab only
   // Hook encapsulates all drag logic, persistence, and constraints
   // Returns width to apply to RightSidebar and startResize for handle's onMouseDown
@@ -214,7 +211,8 @@ const AIViewInner: React.FC<AIViewProps> = ({
     currentModel: workspaceState?.currentModel ?? null,
     canInterrupt: workspaceState?.canInterrupt ?? false,
     showRetryBarrier: workspaceState
-      ? !workspaceState.canInterrupt && hasInterruptedStream(workspaceState.messages)
+      ? !workspaceState.canInterrupt &&
+        hasInterruptedStream(workspaceState.messages, workspaceState.pendingStreamStart)
       : false,
     currentWorkspaceThinking,
     setThinkingLevel,
@@ -245,30 +243,6 @@ const AIViewInner: React.FC<AIViewProps> = ({
     }
   }, [workspaceState, editingMessage]);
 
-  // Force re-evaluation after 2s when last message is a recent user message
-  // This ensures retry barrier appears even if stream-start never arrives
-  // Must be before early return to satisfy React Hooks rules
-  useEffect(() => {
-    if (!workspaceState) return;
-    const { messages, canInterrupt } = workspaceState;
-
-    if (messages.length === 0) return;
-    const lastMessage = messages[messages.length - 1];
-
-    if (lastMessage.type === "user" && !canInterrupt) {
-      const messageAge = Date.now() - (lastMessage.timestamp ?? 0);
-      const timeUntilCheck = Math.max(0, 2100 - messageAge); // 2.1s to ensure we're past threshold
-
-      if (timeUntilCheck > 0) {
-        const timer = setTimeout(() => {
-          // Force re-render to re-evaluate showRetryBarrier
-          setForceRecheck((prev) => prev + 1);
-        }, timeUntilCheck);
-        return () => clearTimeout(timer);
-      }
-    }
-  }, [workspaceState]);
-
   // Return early if workspace state not loaded yet
   if (!workspaceState) {
     return (
@@ -287,14 +261,15 @@ const AIViewInner: React.FC<AIViewProps> = ({
   }
 
   // Extract state from workspace state
-  const { messages, canInterrupt, isCompacting, loading, currentModel } = workspaceState;
+  const { messages, canInterrupt, isCompacting, loading, currentModel, pendingStreamStart } =
+    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);
+  const showRetryBarrier = !canInterrupt && hasInterruptedStream(messages, pendingStreamStart);
 
   // 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)) {
+    if (!hasInterruptedStream(state.messages, state.pendingStreamStart)) {
       return false;
     }
 

src/stores/WorkspaceStore.ts

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

src/utils/messages/StreamingMessageAggregator.ts

@@ -60,6 +60,11 @@ export class StreamingMessageAggregator {
     timestamp: number;
   } | null = null;
 
+  // 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;
+
   // Workspace creation timestamp (used for recency calculation)
   private readonly createdAt?: string;
 
@@ -184,6 +189,29 @@ export class StreamingMessageAggregator {
     return this.messages.size > 0;
   }
 
+  isPendingStreamStart(): boolean {
+    return this.pendingStreamStart;
+  }
+
+  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);
+    }
+  }
+
   getActiveStreams(): StreamingContext[] {
     return Array.from(this.activeStreams.values());
   }
@@ -254,6 +282,9 @@ 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);
+
     // Detect if this stream is compacting by checking if last user message is a compaction-request
     const messages = this.getAllMessages();
     const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
@@ -559,6 +590,11 @@ export class StreamingMessageAggregator {
 
       // Now add the new message
       this.addMessage(incomingMessage);
+
+      // If this is a user message, set pendingStreamStart flag and start timeout
+      if (incomingMessage.role === "user") {
+        this.setPendingStreamStart(true);
+      }
     }
   }
 

src/utils/messages/retryEligibility.test.ts

@@ -128,8 +128,7 @@ describe("hasInterruptedStream", () => {
     expect(hasInterruptedStream(messages)).toBe(false);
   });
 
-  it("returns true when last message is user message sent >2s ago (app restarted during slow model)", () => {
-    const oldTimestamp = Date.now() - 5000; // 5 seconds ago
+  it("returns true when last message is user message (app restarted during slow model)", () => {
     const messages: DisplayedMessage[] = [
       {
         type: "user",
@@ -156,14 +155,12 @@ describe("hasInterruptedStream", () => {
         historyId: "user-2",
         content: "Another question",
         historySequence: 3,
-        timestamp: oldTimestamp,
       },
     ];
-    expect(hasInterruptedStream(messages)).toBe(true);
+    expect(hasInterruptedStream(messages, false)).toBe(true);
   });
 
-  it("returns false when last message is very recent user message (<2s)", () => {
-    const recentTimestamp = Date.now() - 500; // 500ms ago
+  it("returns false when pendingStreamStart is true", () => {
     const messages: DisplayedMessage[] = [
       {
         type: "user",
@@ -190,39 +187,34 @@ describe("hasInterruptedStream", () => {
         historyId: "user-2",
         content: "Another question",
         historySequence: 3,
-        timestamp: recentTimestamp,
       },
     ];
-    expect(hasInterruptedStream(messages)).toBe(false);
+    expect(hasInterruptedStream(messages, true)).toBe(false);
   });
 
-  it("returns true when user message has no response sent >2s ago (slow model scenario)", () => {
-    const oldTimestamp = Date.now() - 3000; // 3 seconds ago
+  it("returns true when user message has no response (slow model scenario)", () => {
     const messages: DisplayedMessage[] = [
       {
         type: "user",
         id: "user-1",
         historyId: "user-1",
         content: "Hello",
         historySequence: 1,
-        timestamp: oldTimestamp,
       },
     ];
-    expect(hasInterruptedStream(messages)).toBe(true);
+    expect(hasInterruptedStream(messages, false)).toBe(true);
   });
 
-  it("returns false when user message was just sent (<2s ago)", () => {
-    const recentTimestamp = Date.now() - 1000; // 1 second ago
+  it("returns false when user message just sent and pendingStreamStart is true", () => {
     const messages: DisplayedMessage[] = [
       {
         type: "user",
         id: "user-1",
         historyId: "user-1",
         content: "Hello",
         historySequence: 1,
-        timestamp: recentTimestamp,
       },
     ];
-    expect(hasInterruptedStream(messages)).toBe(false);
+    expect(hasInterruptedStream(messages, true)).toBe(false);
   });
 });

src/utils/messages/retryEligibility.ts

@@ -15,23 +15,23 @@ 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: Ignore very recent user messages (< 2s) to prevent flash during normal send flow
+ *    - EXCEPT: Not if pendingStreamStart is true (waiting for stream-start event)
  */
-export function hasInterruptedStream(messages: DisplayedMessage[]): boolean {
+export function hasInterruptedStream(
+  messages: DisplayedMessage[],
+  pendingStreamStart = false
+): boolean {
   if (messages.length === 0) return false;
 
-  const lastMessage = messages[messages.length - 1];
+  // Don't show retry barrier if we're waiting for stream-start
+  // This prevents flash during normal send flow
+  if (pendingStreamStart) return false;
 
-  // For user messages, check if enough time has passed to consider it truly interrupted
-  // This prevents the retry barrier from flashing briefly when sending a message
-  if (lastMessage.type === "user") {
-    const messageAge = Date.now() - (lastMessage.timestamp ?? 0);
-    const MIN_AGE_FOR_INTERRUPT = 2000; // 2 seconds
-    return messageAge >= MIN_AGE_FOR_INTERRUPT;
-  }
+  const lastMessage = messages[messages.length - 1];
 
   return (
     lastMessage.type === "stream-error" || // Stream errored out
+    lastMessage.type === "user" || // No response received yet (app restart during slow model)
     (lastMessage.type === "assistant" && lastMessage.isPartial === true) ||
     (lastMessage.type === "tool" && lastMessage.isPartial === true) ||
     (lastMessage.type === "reasoning" && lastMessage.isPartial === true)