🤖 fix: preserve awaiting-input state when question isn't last part

src/browser/components/ChatPane/ChatPane.tsx

@@ -572,7 +572,8 @@ export const ChatPane: React.FC<ChatPaneProps> = (props) => {
         workspaceState.messages,
         workspaceState.pendingStreamStartTime,
         workspaceState.runtimeStatus,
-        workspaceState.lastAbortReason
+        workspaceState.lastAbortReason,
+        workspaceState.awaitingUserQuestion
       )
     : null;
 
@@ -860,7 +861,9 @@ export const ChatPane: React.FC<ChatPaneProps> = (props) => {
                               />
                             )}
                             {isAtCutoff && <EditCutoffBarrier />}
-                            {shouldShowInterruptedBarrier(msg) && <InterruptedBarrier />}
+                            {shouldShowInterruptedBarrier(msg, deferredMessages) && (
+                              <InterruptedBarrier />
+                            )}
                           </React.Fragment>
                         );
                       })}

src/browser/utils/messages/StreamingMessageAggregator.status.test.ts

@@ -93,6 +93,198 @@ describe("ask_user_question waiting state", () => {
 
     expect(aggregator.hasAwaitingUserQuestion()).toBe(true);
   });
+
+  it("keeps awaiting state when ask_user_question is followed by other parts in the same turn", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    aggregator.loadHistoricalMessages([
+      {
+        id: "assistant-1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "call-ask-1",
+            toolName: "ask_user_question",
+            state: "input-available" as const,
+            input: {
+              questions: [
+                {
+                  header: "Approach",
+                  question: "Which approach should we take?",
+                  options: [
+                    { label: "A", description: "Approach A" },
+                    { label: "B", description: "Approach B" },
+                  ],
+                  multiSelect: false,
+                },
+              ],
+            },
+          },
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "call-todo-1",
+            toolName: "todo_write",
+            state: "output-available" as const,
+            input: { todos: [{ content: "Waiting for answers", status: "in_progress" }] },
+            output: { success: true },
+          },
+          { type: "text" as const, text: "Please answer the question above." },
+        ],
+        metadata: {
+          timestamp: 1000,
+          historySequence: 1,
+          partial: true,
+        },
+      },
+    ]);
+
+    expect(aggregator.hasAwaitingUserQuestion()).toBe(true);
+  });
+
+  it("does not treat older question turns as awaiting after chat moves on", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    aggregator.loadHistoricalMessages([
+      {
+        id: "assistant-1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "call-ask-1",
+            toolName: "ask_user_question",
+            state: "input-available" as const,
+            input: {
+              questions: [
+                {
+                  header: "Approach",
+                  question: "Which approach should we take?",
+                  options: [
+                    { label: "A", description: "Approach A" },
+                    { label: "B", description: "Approach B" },
+                  ],
+                  multiSelect: false,
+                },
+              ],
+            },
+          },
+        ],
+        metadata: {
+          timestamp: 1000,
+          historySequence: 1,
+          partial: true,
+        },
+      },
+      {
+        id: "user-2",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "Skipping this and moving on" }],
+        metadata: {
+          timestamp: 2000,
+          historySequence: 2,
+        },
+      },
+    ]);
+
+    expect(aggregator.hasAwaitingUserQuestion()).toBe(false);
+  });
+
+  it("keeps awaiting state even when display truncation hides the ask_user_question row", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    const trailingToolParts = Array.from({ length: 80 }, (_, index) => ({
+      type: "dynamic-tool" as const,
+      toolCallId: `call-todo-${index}`,
+      toolName: "todo_write",
+      state: "output-available" as const,
+      input: { todos: [{ content: `Task ${index}`, status: "in_progress" }] },
+      output: { success: true },
+    }));
+
+    aggregator.loadHistoricalMessages([
+      {
+        id: "assistant-1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "call-ask-1",
+            toolName: "ask_user_question",
+            state: "input-available" as const,
+            input: {
+              questions: [
+                {
+                  header: "Approach",
+                  question: "Which approach should we take?",
+                  options: [
+                    { label: "A", description: "Approach A" },
+                    { label: "B", description: "Approach B" },
+                  ],
+                  multiSelect: false,
+                },
+              ],
+            },
+          },
+          ...trailingToolParts,
+        ],
+        metadata: {
+          timestamp: 1000,
+          historySequence: 1,
+          partial: true,
+        },
+      },
+    ]);
+
+    const displayed = aggregator.getDisplayedMessages();
+    expect(
+      displayed.some(
+        (message) => message.type === "tool" && message.toolName === "ask_user_question"
+      )
+    ).toBe(false);
+    expect(aggregator.hasAwaitingUserQuestion()).toBe(true);
+  });
+
+  it("does not report awaiting input when latest assistant turn has stream error metadata", () => {
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+
+    aggregator.loadHistoricalMessages([
+      {
+        id: "assistant-1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolCallId: "call-ask-1",
+            toolName: "ask_user_question",
+            state: "input-available" as const,
+            input: {
+              questions: [
+                {
+                  header: "Approach",
+                  question: "Which approach should we take?",
+                  options: [
+                    { label: "A", description: "Approach A" },
+                    { label: "B", description: "Approach B" },
+                  ],
+                  multiSelect: false,
+                },
+              ],
+            },
+          },
+        ],
+        metadata: {
+          timestamp: 1000,
+          historySequence: 1,
+          partial: true,
+          error: "Connection dropped",
+          errorType: "network",
+        },
+      },
+    ]);
+
+    expect(aggregator.hasAwaitingUserQuestion()).toBe(false);
+  });
 });
 
 describe("StreamingMessageAggregator - Agent Status", () => {

src/browser/utils/messages/StreamingMessageAggregator.ts

@@ -716,19 +716,41 @@ export class StreamingMessageAggregator {
    * Used to show "Awaiting your input" instead of "streaming..." in the UI.
    */
   hasAwaitingUserQuestion(): boolean {
-    // Only treat the workspace as "awaiting input" when the *latest* displayed
-    // message is an executing ask_user_question tool.
-    //
-    // This avoids false positives from stale historical partials if the user
-    // continued the chat after skipping/canceling the questions.
-    const displayed = this.getDisplayedMessages();
-    const last = displayed[displayed.length - 1];
+    const showSyntheticMessages =
+      typeof window !== "undefined" && window.api?.debugLlmRequest === true;
+
+    // Use untruncated history so long turns cannot hide an awaiting question
+    // behind history-hidden markers in getDisplayedMessages().
+    const allMessages = this.getAllMessages();
+
+    // Find the latest history message that is visible in the transcript.
+    for (let i = allMessages.length - 1; i >= 0; i--) {
+      const message = allMessages[i];
+      const isSynthetic = message.metadata?.synthetic === true;
+      const isUiVisibleSynthetic = message.metadata?.uiVisible === true;
+      if (isSynthetic && !showSyntheticMessages && !isUiVisibleSynthetic) {
+        continue;
+      }
 
-    if (last?.type !== "tool") {
-      return false;
+      if (message.role !== "assistant") {
+        return false;
+      }
+
+      // Error metadata means this turn ended in failure; surface retry/error state
+      // instead of presenting the turn as awaiting user input.
+      if (message.metadata?.error != null) {
+        return false;
+      }
+
+      return message.parts.some(
+        (part) =>
+          isDynamicToolPart(part) &&
+          part.toolName === "ask_user_question" &&
+          part.state === "input-available"
+      );
     }
 
-    return last.toolName === "ask_user_question" && last.status === "executing";
+    return false;
   }
 
   /**

src/browser/utils/messages/messageUtils.test.ts

@@ -28,6 +28,39 @@ describe("shouldShowInterruptedBarrier", () => {
     expect(shouldShowInterruptedBarrier(msg)).toBe(false);
   });
 
+  it("returns false for trailing partial rows when latest turn contains executing ask_user_question", () => {
+    const questionTool: DisplayedMessage = {
+      type: "tool",
+      id: "tool-ask",
+      historyId: "assistant-1",
+      toolName: "ask_user_question",
+      toolCallId: "call-ask",
+      args: { questions: [] },
+      status: "executing",
+      isPartial: true,
+      historySequence: 2,
+      streamSequence: 0,
+      isLastPartOfMessage: false,
+    };
+
+    const trailingPartialText: DisplayedMessage = {
+      type: "assistant",
+      id: "assistant-tail",
+      historyId: "assistant-1",
+      content: "Please answer above.",
+      historySequence: 2,
+      streamSequence: 1,
+      isStreaming: false,
+      isPartial: true,
+      isLastPartOfMessage: true,
+      isCompacted: false,
+      isIdleCompacted: false,
+    };
+
+    const messages = [questionTool, trailingPartialText];
+
+    expect(shouldShowInterruptedBarrier(trailingPartialText, messages)).toBe(false);
+  });
   it("returns false for decorative compaction boundary rows", () => {
     const msg: DisplayedMessage = {
       type: "compaction-boundary",

src/browser/utils/messages/messageUtils.ts

@@ -1,6 +1,10 @@
 import type { DisplayedMessage } from "@/common/types/message";
 import { formatReviewForModel } from "@/common/types/review";
 import type { BashOutputToolArgs } from "@/common/types/tools";
+import {
+  getLastNonDecorativeMessage,
+  hasExecutingAskUserQuestionInLatestTurn,
+} from "@/common/utils/messages/retryEligibility";
 
 /**
  * Returns the text that should be placed into the ChatInput when editing a user message.
@@ -72,7 +76,10 @@ export interface BashOutputGroupInfo {
  * - Message was interrupted (isPartial) AND not currently streaming
  * - For multi-part messages, only show on the last part
  */
-export function shouldShowInterruptedBarrier(msg: DisplayedMessage): boolean {
+export function shouldShowInterruptedBarrier(
+  msg: DisplayedMessage,
+  allMessages: DisplayedMessage[] = [msg]
+): boolean {
   if (
     msg.type === "user" ||
     msg.type === "stream-error" ||
@@ -85,9 +92,15 @@ export function shouldShowInterruptedBarrier(msg: DisplayedMessage): boolean {
 
   // ask_user_question is intentionally a "waiting for input" state. Even if the
   // underlying message is a persisted partial (e.g. after app restart), we keep
-  // it answerable instead of showing "Interrupted".
-  if (msg.type === "tool" && msg.toolName === "ask_user_question" && msg.status === "executing") {
-    return false;
+  // the full latest turn answerable instead of showing "Interrupted" on any
+  // trailing parts from that same assistant message.
+  if (hasExecutingAskUserQuestionInLatestTurn(allMessages)) {
+    const lastMessage = getLastNonDecorativeMessage(allMessages);
+    if (lastMessage && "historyId" in msg && "historyId" in lastMessage) {
+      if (msg.historyId === lastMessage.historyId) {
+        return false;
+      }
+    }
   }
 
   // Only show on the last part of multi-part messages