fix(queue): never destroy user messages sent while no ask is pending

The primary 'my message went nowhere' sink: ask() clears askResponse/
askResponseText at the start of every complete ask, so a messageResponse
arriving while no ask() was blocked (webview raced a phase transition —
e.g. during the API-request phase — or submitUserMessage was invoked
mid-stream) was silently destroyed.

- Task: track pendingAskCount around ask()'s wait region; orphaned
  text-bearing messageResponses are rerouted into the task's message
  queue, where the queue/steer handoff delivers them at the next safe
  boundary (followup/idle ask auto-dispatch, resume, or run end).
- ChatView: when a state push built during a transient no-current-task
  window (cancel/rehydrate, delegation swap) blips currentTaskId to
  undefined, queue with the last known task id for the visible
  conversation instead of dropping the message on the floor.
- Tests: pin the orphaned-response invariants (queued not destroyed,
  direct delivery while an ask waits, auto-delivery at the next
  followup ask, button responses unchanged) and the blip fallback.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: allquixotic

src/core/task/Task.ts

@@ -314,6 +314,11 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	private askResponseImages?: string[]
 	public lastMessageTs?: number
 	private autoApprovalTimeoutRef?: NodeJS.Timeout
+	// Number of ask() calls currently blocked waiting for a response. Used by
+	// handleWebviewAskResponse to detect "orphaned" messageResponses: ask() clears
+	// askResponse/askResponseText at the start of every new complete ask, so a
+	// response written while nothing is waiting would be silently destroyed.
+	private pendingAskCount = 0
 
 	// Tool Use
 	consecutiveMistakeCount: number = 0
@@ -1383,97 +1388,108 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 		const timeouts: NodeJS.Timeout[] = []
 
-		// Auto-approval (state/approval) was resolved above before the message was added.
-		if (approval.decision === "approve") {
-			this.approveAsk()
-		} else if (approval.decision === "deny") {
-			this.denyAsk()
-		} else if (approval.decision === "timeout") {
-			// Store the auto-approval timeout so it can be cancelled if user interacts
-			this.autoApprovalTimeoutRef = setTimeout(() => {
-				const { askResponse, text, images } = approval.fn()
-				this.handleWebviewAskResponse(askResponse, text, images)
-				this.autoApprovalTimeoutRef = undefined
-			}, approval.timeout)
-			timeouts.push(this.autoApprovalTimeoutRef)
-		}
-
-		// The state is mutable if the message is complete and the task will
-		// block (via the `pWaitFor`).
-		const isBlocking = !(this.askResponse !== undefined || this.lastMessageTs !== askTs)
-		const hasDeferredMessage = !this.messageQueueService.isEmpty()
-		const shouldPauseQueuedDrainForAsk = this.deferQueuedMessageDrainUntilResume && isResumableAsk(type)
-		const shouldAutoDispatchDeferredMessageForAsk =
-			this.canAutoDispatchDeferredMessageForAsk(type) && !shouldPauseQueuedDrainForAsk
-		const hasAutoDispatchCandidate = hasDeferredMessage && shouldAutoDispatchDeferredMessageForAsk
-		const isStatusMutable = !partial && isBlocking && !hasAutoDispatchCandidate && approval.decision === "ask"
-
-		if (isStatusMutable) {
-			const statusMutationTimeout = 2_000
-
-			if (isInteractiveAsk(type)) {
-				timeouts.push(
-					setTimeout(() => {
-						const message = this.findMessageByTimestamp(askTs)
-
-						if (message) {
-							this.interactiveAsk = message
-							this.emit(RooCodeEventName.TaskInteractive, this.taskId)
-							/* v8 ignore next 3 -- fires inside 2s timer after ask() resolves; not reachable in unit tests */
-							void this.postTaskMessageToWebview({ type: "interactionRequired" }).catch((error) => {
-								console.error("[Task#ask] postTaskMessageToWebview interactionRequired failed:", error)
-							})
-						}
-					}, statusMutationTimeout),
-				)
-			} else if (isResumableAsk(type)) {
-				timeouts.push(
-					setTimeout(() => {
-						const message = this.findMessageByTimestamp(askTs)
-
-						if (message) {
-							this.resumableAsk = message
-							this.emit(RooCodeEventName.TaskResumable, this.taskId)
-						}
-					}, statusMutationTimeout),
-				)
-			} else if (isIdleAsk(type)) {
-				timeouts.push(
-					setTimeout(() => {
-						const message = this.findMessageByTimestamp(askTs)
-
-						if (message) {
-							this.idleAsk = message
-							this.emit(RooCodeEventName.TaskIdle, this.taskId)
-						}
-					}, statusMutationTimeout),
-				)
+		// From here until the pWaitFor below resolves, a response can legitimately arrive
+		// (auto-approval, button click, auto-dispatched queue message). Mark the ask as
+		// pending so handleWebviewAskResponse delivers directly instead of queueing.
+		this.pendingAskCount++
+		try {
+			// Auto-approval (state/approval) was resolved above before the message was added.
+			if (approval.decision === "approve") {
+				this.approveAsk()
+			} else if (approval.decision === "deny") {
+				this.denyAsk()
+			} else if (approval.decision === "timeout") {
+				// Store the auto-approval timeout so it can be cancelled if user interacts
+				this.autoApprovalTimeoutRef = setTimeout(() => {
+					const { askResponse, text, images } = approval.fn()
+					this.handleWebviewAskResponse(askResponse, text, images)
+					this.autoApprovalTimeoutRef = undefined
+				}, approval.timeout)
+				timeouts.push(this.autoApprovalTimeoutRef)
 			}
-		} else if (hasAutoDispatchCandidate) {
-			this.consumeDeferredMessageForAsk(type)
-		}
 
-		// Wait for askResponse to be set
-		await pWaitFor(
-			() => {
-				if (this.abort) {
-					return true
-				}
-				if (this.askResponse !== undefined || this.lastMessageTs !== askTs) {
-					return true
+			// The state is mutable if the message is complete and the task will
+			// block (via the `pWaitFor`).
+			const isBlocking = !(this.askResponse !== undefined || this.lastMessageTs !== askTs)
+			const hasDeferredMessage = !this.messageQueueService.isEmpty()
+			const shouldPauseQueuedDrainForAsk = this.deferQueuedMessageDrainUntilResume && isResumableAsk(type)
+			const shouldAutoDispatchDeferredMessageForAsk =
+				this.canAutoDispatchDeferredMessageForAsk(type) && !shouldPauseQueuedDrainForAsk
+			const hasAutoDispatchCandidate = hasDeferredMessage && shouldAutoDispatchDeferredMessageForAsk
+			const isStatusMutable = !partial && isBlocking && !hasAutoDispatchCandidate && approval.decision === "ask"
+
+			if (isStatusMutable) {
+				const statusMutationTimeout = 2_000
+
+				if (isInteractiveAsk(type)) {
+					timeouts.push(
+						setTimeout(() => {
+							const message = this.findMessageByTimestamp(askTs)
+
+							if (message) {
+								this.interactiveAsk = message
+								this.emit(RooCodeEventName.TaskInteractive, this.taskId)
+								/* v8 ignore next 3 -- fires inside 2s timer after ask() resolves; not reachable in unit tests */
+								void this.postTaskMessageToWebview({ type: "interactionRequired" }).catch((error) => {
+									console.error(
+										"[Task#ask] postTaskMessageToWebview interactionRequired failed:",
+										error,
+									)
+								})
+							}
+						}, statusMutationTimeout),
+					)
+				} else if (isResumableAsk(type)) {
+					timeouts.push(
+						setTimeout(() => {
+							const message = this.findMessageByTimestamp(askTs)
+
+							if (message) {
+								this.resumableAsk = message
+								this.emit(RooCodeEventName.TaskResumable, this.taskId)
+							}
+						}, statusMutationTimeout),
+					)
+				} else if (isIdleAsk(type)) {
+					timeouts.push(
+						setTimeout(() => {
+							const message = this.findMessageByTimestamp(askTs)
+
+							if (message) {
+								this.idleAsk = message
+								this.emit(RooCodeEventName.TaskIdle, this.taskId)
+							}
+						}, statusMutationTimeout),
+					)
 				}
+			} else if (hasAutoDispatchCandidate) {
+				this.consumeDeferredMessageForAsk(type)
+			}
 
-				// If a deferred message arrives while we're blocked on a handoff ask (for example
-				// a follow-up suggestion click that was queued while the agent still owned the turn),
-				// consume it immediately so the task doesn't hang.
-				if (shouldAutoDispatchDeferredMessageForAsk && !this.messageQueueService.isEmpty()) {
-					this.consumeDeferredMessageForAsk(type)
-				}
+			// Wait for askResponse to be set
+			await pWaitFor(
+				() => {
+					if (this.abort) {
+						return true
+					}
+					if (this.askResponse !== undefined || this.lastMessageTs !== askTs) {
+						return true
+					}
 
-				return false
-			},
-			{ interval: 100 },
-		)
+					// If a deferred message arrives while we're blocked on a handoff ask (for example
+					// a follow-up suggestion click that was queued while the agent still owned the turn),
+					// consume it immediately so the task doesn't hang.
+					if (shouldAutoDispatchDeferredMessageForAsk && !this.messageQueueService.isEmpty()) {
+						this.consumeDeferredMessageForAsk(type)
+					}
+
+					return false
+				},
+				{ interval: 100 },
+			)
+		} finally {
+			this.pendingAskCount--
+		}
 
 		if (this.abort) {
 			throw new Error(`[RooCode#ask] task ${this.taskId}.${this.instanceId} aborted`)
@@ -1507,6 +1523,22 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	}
 
 	handleWebviewAskResponse(askResponse: ClineAskResponse, text?: string, images?: string[]) {
+		// Orphaned message guard: if a text-bearing response arrives while NO ask() is
+		// waiting (e.g. the webview raced a phase transition and sent askResponse instead
+		// of queueMessage, or submitUserMessage was invoked mid-stream via the API),
+		// writing it to askResponse* would silently destroy it — ask() clears those
+		// fields at the start of every new ask. Route it into the message queue instead,
+		// where the normal queue/steer handoff will deliver it at the next safe boundary.
+		if (
+			askResponse === "messageResponse" &&
+			this.pendingAskCount === 0 &&
+			!this.abort &&
+			(text?.trim() || images?.length)
+		) {
+			this.messageQueueService.addMessage(text ?? "", images)
+			return
+		}
+
 		// Clear any pending auto-approval timeout when user responds
 		this.cancelAutoApprovalTimeout()
 

src/core/task/__tests__/Task.spec.ts

@@ -1556,8 +1556,17 @@ describe("Cline", () => {
 
 				// Verify handleWebviewAskResponse was called directly (not webview)
 				expect(handleResponseSpy).toHaveBeenCalledWith("messageResponse", "test message", ["image1.png"])
-				// Should NOT route through webview anymore
-				expect(mockProvider.postMessageToWebview).not.toHaveBeenCalled()
+				// With no ask pending, the message must be preserved in the queue rather
+				// than written into the askResponse fields (which the next ask() clears).
+				expect(task.messageQueueService.getMessagesByMode("queue")).toEqual([
+					expect.objectContaining({ text: "test message", images: ["image1.png"] }),
+				])
+				// Should NOT route through the webview as user input (only queue-state
+				// broadcasts are allowed).
+				const inputRoutingCalls = vi
+					.mocked(mockProvider.postMessageToWebview)
+					.mock.calls.filter(([message]: any[]) => message?.type === "invoke")
+				expect(inputRoutingCalls).toHaveLength(0)
 			})
 
 			it("should handle empty messages gracefully", async () => {
@@ -2949,6 +2958,122 @@ describe("Deferred message dispatch boundaries", () => {
 	})
 })
 
+describe("Orphaned askResponse routing", () => {
+	// ask() clears askResponse/askResponseText at the start of every new complete ask,
+	// so a messageResponse that arrives while NO ask() is blocked would be silently
+	// destroyed (the reported "my message went nowhere" bug: e.g. the webview raced a
+	// phase transition and sent askResponse instead of queueMessage during the API
+	// request phase). These specs pin the invariant: such responses are rerouted into
+	// the task's message queue and delivered at the next safe boundary instead.
+
+	function createProvider(): any {
+		const storageUri = { fsPath: path.join(os.tmpdir(), "test-storage") }
+		const ctx = {
+			globalState: {
+				get: vi.fn().mockImplementation((_key: keyof GlobalState) => undefined),
+				update: vi.fn().mockResolvedValue(undefined),
+				keys: vi.fn().mockReturnValue([]),
+			},
+			globalStorageUri: storageUri,
+			workspaceState: {
+				get: vi.fn().mockImplementation((_key) => undefined),
+				update: vi.fn().mockResolvedValue(undefined),
+				keys: vi.fn().mockReturnValue([]),
+			},
+			secrets: {
+				get: vi.fn().mockResolvedValue(undefined),
+				store: vi.fn().mockResolvedValue(undefined),
+				delete: vi.fn().mockResolvedValue(undefined),
+			},
+			extensionUri: { fsPath: "/mock/extension/path" },
+			extension: { packageJSON: { version: "1.0.0" } },
+		} as unknown as vscode.ExtensionContext
+
+		const output = {
+			appendLine: vi.fn(),
+			append: vi.fn(),
+			clear: vi.fn(),
+			show: vi.fn(),
+			hide: vi.fn(),
+			dispose: vi.fn(),
+		}
+
+		const provider = new ClineProvider(ctx, output as any, "sidebar", new ContextProxy(ctx)) as any
+		provider.postMessageToWebview = vi.fn().mockResolvedValue(undefined)
+		provider.postStateToWebview = vi.fn().mockResolvedValue(undefined)
+		provider.postStateToWebviewWithoutTaskHistory = vi.fn().mockResolvedValue(undefined)
+		provider.getState = vi.fn().mockResolvedValue({})
+		return provider
+	}
+
+	const apiConfig: ProviderSettings = {
+		apiProvider: "anthropic",
+		apiModelId: "claude-3-5-sonnet-20241022",
+		apiKey: "test-api-key",
+	} as any
+
+	function createTask(): Task {
+		return new Task({
+			provider: createProvider(),
+			apiConfiguration: apiConfig,
+			task: "initial task",
+			startTask: false,
+		})
+	}
+
+	it("queues a messageResponse that arrives while no ask is pending", () => {
+		const task = createTask()
+
+		task.handleWebviewAskResponse("messageResponse", "orphaned message", ["img.png"])
+
+		// The message must land in the queue instead of the askResponse fields
+		// (where the next ask() would wipe it).
+		expect(task.messageQueueService.getMessagesByMode("queue")).toEqual([
+			expect.objectContaining({ text: "orphaned message", images: ["img.png"], deliveryMode: "queue" }),
+		])
+		expect((task as any).askResponse).toBeUndefined()
+		expect((task as any).askResponseText).toBeUndefined()
+	})
+
+	it("still records button responses (no text) while no ask is pending", () => {
+		const task = createTask()
+
+		task.handleWebviewAskResponse("yesButtonClicked")
+
+		expect(task.messageQueueService.isEmpty()).toBe(true)
+		expect((task as any).askResponse).toBe("yesButtonClicked")
+	})
+
+	it("delivers a messageResponse directly while an ask is blocked waiting", () => {
+		const task = createTask()
+
+		// Simulate an ask() blocked in its wait region (p-wait-for is module-mocked in
+		// this spec, so drive the pending counter directly).
+		;(task as any).pendingAskCount = 1
+		task.handleWebviewAskResponse("messageResponse", "direct answer")
+
+		expect((task as any).askResponse).toBe("messageResponse")
+		expect((task as any).askResponseText).toBe("direct answer")
+		// Nothing should have leaked into the queue.
+		expect(task.messageQueueService.isEmpty()).toBe(true)
+	})
+
+	it("auto-delivers a previously orphaned message at the next followup ask", async () => {
+		const task = createTask()
+		vi.spyOn(task as any, "saveClineMessages").mockResolvedValue(undefined)
+
+		// Orphaned: no ask pending yet.
+		task.handleWebviewAskResponse("messageResponse", "queued while streaming")
+		expect(task.messageQueueService.isEmpty()).toBe(false)
+
+		// The next auto-dispatchable ask must consume it instead of hanging.
+		const result = await task.ask("followup", "next question")
+		expect(result.response).toBe("messageResponse")
+		expect(result.text).toBe("queued while streaming")
+		expect(task.messageQueueService.isEmpty()).toBe(true)
+	})
+})
+
 describe("pushToolResultToUserContent", () => {
 	let mockProvider: any
 	let mockApiConfig: ProviderSettings