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

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

@@ -93,6 +93,102 @@ 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);
+  });
 });
 
 describe("StreamingMessageAggregator - Agent Status", () => {

src/browser/utils/messages/StreamingMessageAggregator.ts

@@ -716,19 +716,37 @@ 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];
 
-    if (last?.type !== "tool") {
+    if (!last || !("historyId" in last)) {
       return false;
     }
 
-    return last.toolName === "ask_user_question" && last.status === "executing";
+    // Treat the latest assistant turn as "awaiting input" when it contains an
+    // executing ask_user_question tool, even if later parts in the same turn
+    // (text or other tool calls) were emitted after the question.
+    //
+    // We intentionally scope to the latest historyId only so stale historical
+    // questions do not keep the workspace in an awaiting state once the chat has
+    // moved on to a newer message.
+    const latestHistoryId = last.historyId;
+    for (let i = displayed.length - 1; i >= 0; i--) {
+      const message = displayed[i];
+      if (!("historyId" in message) || message.historyId !== latestHistoryId) {
+        break;
+      }
+
+      if (
+        message.type === "tool" &&
+        message.toolName === "ask_user_question" &&
+        message.status === "executing"
+      ) {
+        return true;
+      }
+    }
+
+    return false;
   }
 
   /**