fix(task): enqueue streaming input before child completion

Author: edelauna

src/core/task/Task.ts

@@ -29,6 +29,7 @@ import {
 	type ContextTruncation,
 	type ClineMessage,
 	type ClineSay,
+	type ClineSayTool,
 	type ClineAsk,
 	type ToolProgressStatus,
 	type HistoryItem,
@@ -1150,10 +1151,10 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		return undefined
 	}
 
-	private drainQueuedMessageIntoAskResponse(): void {
+	private drainQueuedMessageIntoAskResponse(allowResolvedAskOverride = false): void {
 		// A synchronous auto-approval may already have resolved the ask before the
 		// entry queue snapshot is acted on. Never replace that resolved response.
-		if (this.askResponse !== undefined) {
+		if (this.askResponse !== undefined && !allowResolvedAskOverride) {
 			return
 		}
 
@@ -1328,6 +1329,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// Keep queued user messages intact during command_output asks. Those asks
 		// are terminal flow-control, not conversational turns.
 		const shouldDrainQueuedMessageForAsk = type !== "command_output"
+		let isFinishTaskAsk = false
+		if (type === "tool") {
+			try {
+				isFinishTaskAsk = (JSON.parse(text || "{}") as ClineSayTool).tool === "finishTask"
+			} catch {
+				// Invalid tool payloads are handled by their caller; they are not finishTask asks.
+			}
+		}
 		const isStatusMutable = !partial && isBlocking && !isMessageQueued && approval.decision === "ask"
 
 		if (isStatusMutable) {
@@ -1373,7 +1382,9 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			}
 		} else if (isMessageQueued && shouldDrainQueuedMessageForAsk) {
 			// This branch acts on the queue state captured when the ask was entered.
-			this.drainQueuedMessageIntoAskResponse()
+			// A queued instruction must interrupt finishTask before the child returns
+			// to its parent, even when subtask completion is otherwise auto-approved.
+			this.drainQueuedMessageIntoAskResponse(isFinishTaskAsk)
 		}
 
 		// Wait for askResponse to be set

src/core/task/__tests__/ask-queued-message-drain.spec.ts

@@ -94,6 +94,43 @@ describe("Task.ask queued message drain", () => {
 		expect(task.messageQueueService.messages[0]?.text).toBe("change direction")
 	})
 
+	it("lets queued input interrupt an auto-approved finishTask ask", async () => {
+		const task = buildTask({
+			autoApprovalEnabled: true,
+			alwaysAllowSubtasks: true,
+		})
+		task.messageQueueService.addMessage("Use the queued instruction before completing.")
+
+		const result = await task.ask("tool", JSON.stringify({ tool: "finishTask" }), false)
+
+		expect(result).toEqual({
+			response: "messageResponse",
+			text: "Use the queued instruction before completing.",
+			images: undefined,
+		})
+		expect(task.messageQueueService.isEmpty()).toBe(true)
+	})
+
+	it("preserves queued input behind an ordinary auto-approved tool ask", async () => {
+		const task = buildTask({ autoApprovalEnabled: true })
+		task.messageQueueService.addMessage("change direction")
+
+		const result = await task.ask("tool", JSON.stringify({ tool: "updateTodoList" }), false)
+
+		expect(result.response).toBe("yesButtonClicked")
+		expect(task.messageQueueService.messages).toHaveLength(1)
+	})
+
+	it("treats queued input as feedback when a tool ask payload is malformed", async () => {
+		const task = buildTask()
+		task.messageQueueService.addMessage("change direction")
+
+		const result = await task.ask("tool", "{", false)
+
+		expect(result).toMatchObject({ response: "messageResponse", text: "change direction" })
+		expect(task.messageQueueService.isEmpty()).toBe(true)
+	})
+
 	it("does not consume messages that were queued before a command_output ask", async () => {
 		const task = buildTask()
 		task.messageQueueService.addMessage("1+1=?")

src/core/tools/__tests__/readFileTool.spec.ts

@@ -687,6 +687,22 @@ describe("ReadFileTool", () => {
 			})
 			parseSpy.mockRestore()
 		})
+
+		it("denies batch reads for a queued message response without text", async () => {
+			const task = Object.create(Task.prototype) as Task
+			Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true })
+			Object.assign(task, createMockTask())
+			task.ask = vi.fn().mockResolvedValue({ response: "messageResponse", text: undefined, images: undefined })
+			const fileResults = [
+				{ path: "one.ts", status: "pending" as const, entry: { path: "one.ts", mode: "slice" as const } },
+				{ path: "two.ts", status: "pending" as const, entry: { path: "two.ts", mode: "slice" as const } },
+			]
+
+			await readFileTool["requestApproval"](task, fileResults, () => {})
+
+			expect(task.say).not.toHaveBeenCalledWith("user_feedback", expect.anything(), expect.anything())
+			expect(task.didRejectTool).toBe(true)
+		})
 	})
 
 	describe("output structure", () => {

src/extension/__tests__/api-send-message.spec.ts

@@ -56,6 +56,42 @@ describe("API - SendMessage Command", () => {
 		})
 	})
 
+	it("should enqueue directly when the current task is streaming", async () => {
+		const addMessage = vi.fn()
+		const messageText = "Use this before completing"
+		const images = ["data:image/png;base64,image1data"]
+		const currentTask = {
+			isStreaming: true,
+			messageQueueService: { addMessage },
+		}
+		mockProvider.getCurrentTask = vi.fn().mockReturnValue(currentTask)
+
+		await api.sendMessage(messageText, images)
+
+		expect(addMessage).toHaveBeenCalledWith(messageText, images)
+		expect(mockPostMessageToWebview).not.toHaveBeenCalled()
+	})
+
+	it("should retain webview routing when the current task is not streaming", async () => {
+		const addMessage = vi.fn()
+		const messageText = "Answer the current ask"
+		const currentTask = {
+			isStreaming: false,
+			messageQueueService: { addMessage },
+		}
+		mockProvider.getCurrentTask = vi.fn().mockReturnValue(currentTask)
+
+		await api.sendMessage(messageText)
+
+		expect(addMessage).not.toHaveBeenCalled()
+		expect(mockPostMessageToWebview).toHaveBeenCalledWith({
+			type: "invoke",
+			invoke: "sendMessage",
+			text: messageText,
+			images: undefined,
+		})
+	})
+
 	it("should handle SendMessage command with text and images", async () => {
 		// Arrange
 		const messageText = "Analyze this image"

src/extension/api.ts

@@ -271,6 +271,15 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 	public async sendMessage(text?: string, images?: string[]) {
 		const currentTask = this.sidebarProvider.getCurrentTask()
 
+		// API callers need the returned promise to mean that sequencing-critical
+		// input has reached the active task. During a stream, the webview would
+		// only relay this message back as queueMessage asynchronously, so enqueue
+		// it in the extension host instead of racing task completion.
+		if (currentTask?.isStreaming) {
+			currentTask.messageQueueService.addMessage(text ?? "", images)
+			return
+		}
+
 		// In headless/sandbox flows the webview may not be launched, so routing
 		// through invoke=sendMessage drops the message. Deliver directly to the
 		// task ask-response channel instead.