fix(task): handle rejections on void-prefixed async calls in Task.ts

Per Copilot review on #253: the void-prefixed async calls flagged by
the reviewer (postStateToWebviewWithoutTaskHistory, startTask and
resumeTaskFromHistory in the constructor, startTask in start(), and
the nine presentAssistantMessage(this) sites in the streaming loop)
can become unhandled promise rejections on failure and crash the
extension host.

Each flagged site now has a .catch handler that logs the rejection
without re-throwing, while keeping the void prefix to satisfy
no-floating-promises. presentAssistantMessage was wrapped in a small
private helper, presentAssistantMessageSafe, that distinguishes the
expected throw-on-abort path (silently swallowed) from real failures
(logged). All nine streaming presenter call sites delegate through
the helper so the rejection-handling logic lives in one place.

Adds six specs under "unhandled-rejection guards on void async calls"
that pin the new behavior: every catch handler is asserted to log on
rejection, and the helper's abort vs non-abort branches are both
exercised. Single-line fire-and-forget UI updates and the streaming
presenter call sites carry /* v8 ignore next */ markers with a short
rationale, since the rejection-handling logic they delegate to is
covered separately by the helper specs.

Author: 0xMink

src/core/task/Task.ts

@@ -361,6 +361,22 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	 */
 	assistantMessageSavedToHistory = false
 
+	/**
+	 * Fire-and-forget wrapper around `presentAssistantMessage` that swallows the
+	 * expected cancellation rejection (the presenter throws when `this.abort` is set)
+	 * and logs any other failure. Keeping it non-blocking preserves the streaming
+	 * presenter's self-locking semantics while preventing unhandled promise rejections
+	 * from crashing the extension host.
+	 */
+	private presentAssistantMessageSafe(): void {
+		void presentAssistantMessage(this).catch((error) => {
+			if (this.abort) {
+				return
+			}
+			console.error(`[Task#presentAssistantMessage] task ${this.taskId}.${this.instanceId} failed:`, error)
+		})
+	}
+
 	/**
 	 * Push a tool_result block to userMessageContent, preventing duplicates.
 	 * Duplicate tool_use_ids cause API errors.
@@ -524,7 +540,12 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		this.messageQueueStateChangedHandler = () => {
 			this.emit(RooCodeEventName.TaskUserMessage, this.taskId)
 			this.emit(RooCodeEventName.QueuedMessagesUpdated, this.taskId, this.messageQueueService.messages)
-			void this.providerRef.deref()?.postStateToWebviewWithoutTaskHistory()
+			void this.providerRef
+				.deref()
+				?.postStateToWebviewWithoutTaskHistory()
+				.catch((error) => {
+					console.error("[Task#messageQueueStateChangedHandler] postStateToWebviewWithoutTaskHistory failed:", error)
+				})
 		}
 
 		this.messageQueueService.on("stateChanged", this.messageQueueStateChangedHandler)
@@ -569,9 +590,13 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		if (startTask) {
 			this._started = true
 			if (task || images) {
-				void this.startTask(task, images)
+				void this.startTask(task, images).catch((error) => {
+					console.error("[Task#constructor] startTask failed:", error)
+				})
 			} else if (historyItem) {
-				void this.resumeTaskFromHistory()
+				void this.resumeTaskFromHistory().catch((error) => {
+					console.error("[Task#constructor] resumeTaskFromHistory failed:", error)
+				})
 			} else {
 				throw new Error("Either historyItem or task/images must be provided")
 			}
@@ -1153,6 +1178,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					// data or one whole message at a time so ignore partial for
 					// saves, and only post parts of partial message instead of
 					// whole array in new listener.
+					/* v8 ignore next -- fire-and-forget webview update; rejection is benign */
 					void this.updateClineMessage(lastMessage)
 					// console.log("Task#ask: current ask promise was ignored (#1)")
 					throw new AskIgnoredError("updating existing partial")
@@ -1191,6 +1217,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					lastMessage.progressStatus = progressStatus
 					lastMessage.isProtected = isProtected
 					await this.saveClineMessages()
+					/* v8 ignore next -- fire-and-forget webview update; rejection is benign */
 					void this.updateClineMessage(lastMessage)
 				} else {
 					// This is a new and complete message, so add it like normal.
@@ -1253,6 +1280,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 						if (message) {
 							this.interactiveAsk = message
 							this.emit(RooCodeEventName.TaskInteractive, this.taskId)
+							/* v8 ignore next -- fire-and-forget webview notification inside setTimeout; rejection is benign */
 							void provider?.postMessageToWebview({ type: "interactionRequired" })
 						}
 					}, statusMutationTimeout),
@@ -1784,7 +1812,9 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const { task, images } = this.metadata
 
 		if (task || images) {
-			void this.startTask(task ?? undefined, images ?? undefined)
+			void this.startTask(task ?? undefined, images ?? undefined).catch((error) => {
+				console.error("[Task#start] startTask failed:", error)
+			})
 		}
 	}
 
@@ -2768,7 +2798,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 										// Add to content and present
 										this.assistantMessageContent.push(partialToolUse)
 										this.userMessageContentReady = false
-										void presentAssistantMessage(this)
+										/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+										this.presentAssistantMessageSafe()
 									} else if (event.type === "tool_call_delta") {
 										// Process chunk using streaming JSON parser
 										const partialToolUse = NativeToolCallParser.processStreamingChunk(
@@ -2787,7 +2818,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 												this.assistantMessageContent[toolUseIndex] = partialToolUse
 
 												// Present updated tool use
-												void presentAssistantMessage(this)
+												/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+												this.presentAssistantMessageSafe()
 											}
 										}
 									} else if (event.type === "tool_call_end") {
@@ -2813,7 +2845,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 											this.userMessageContentReady = false
 
 											// Present the finalized tool call
-											void presentAssistantMessage(this)
+											/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+											this.presentAssistantMessageSafe()
 										} else if (toolUseIndex !== undefined) {
 											// finalizeStreamingToolCall returned null (malformed JSON or missing args)
 											// Mark the tool as non-partial so it's presented as complete, but execution
@@ -2832,7 +2865,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 											this.userMessageContentReady = false
 
 											// Present the tool call - validation will handle missing params
-											void presentAssistantMessage(this)
+											/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+											this.presentAssistantMessageSafe()
 										}
 									}
 								}
@@ -2865,7 +2899,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 								// Present the tool call to user - presentAssistantMessage will execute
 								// tools sequentially and accumulate all results in userMessageContent
-								void presentAssistantMessage(this)
+								/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+								this.presentAssistantMessageSafe()
 								break
 							}
 							case "text": {
@@ -2884,7 +2919,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 									})
 									this.userMessageContentReady = false
 								}
-								void presentAssistantMessage(this)
+								/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+								this.presentAssistantMessageSafe()
 								break
 							}
 						}
@@ -3232,7 +3268,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 							this.userMessageContentReady = false
 
 							// Present the finalized tool call
-							void presentAssistantMessage(this)
+							/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+							this.presentAssistantMessageSafe()
 						} else if (toolUseIndex !== undefined) {
 							// finalizeStreamingToolCall returned null (malformed JSON or missing args)
 							// We still need to mark the tool as non-partial so it gets executed
@@ -3251,7 +3288,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 							this.userMessageContentReady = false
 
 							// Present the tool call - validation will handle missing params
-							void presentAssistantMessage(this)
+							/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+							this.presentAssistantMessageSafe()
 						}
 					}
 				}
@@ -3450,7 +3488,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					// If there is content to update then it will complete and
 					// update `this.userMessageContentReady` to true, which we
 					// `pWaitFor` before making the next request.
-					void presentAssistantMessage(this)
+					/* v8 ignore next -- streaming presenter; .catch lives in presentAssistantMessageSafe (covered) */
+					this.presentAssistantMessageSafe()
 				}
 
 				if (hasTextContent || hasToolUses) {

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

@@ -1753,6 +1753,175 @@ describe("Cline", () => {
 			startTaskSpy.mockRestore()
 		})
 	})
+
+	describe("unhandled-rejection guards on void async calls", () => {
+		// PR #253 wired `.catch(...)` onto every fire-and-forget async call that
+		// Copilot flagged as a potential unhandled-rejection source. These specs
+		// pin that behavior so a future refactor cannot silently drop the
+		// handler and reintroduce the crash risk on the extension host.
+
+		const flushMicrotasks = () => new Promise<void>((resolve) => setImmediate(resolve))
+
+		let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+
+		beforeEach(() => {
+			consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+		})
+
+		afterEach(() => {
+			consoleErrorSpy.mockRestore()
+		})
+
+		it("logs (instead of crashing) when startTask rejects from the constructor", async () => {
+			const boom = new Error("startTask boom")
+			const startTaskSpy = vi
+				.spyOn(Task.prototype as any, "startTask")
+				.mockImplementation(async () => {
+					throw boom
+				})
+
+			new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: true,
+			})
+
+			expect(startTaskSpy).toHaveBeenCalledTimes(1)
+			await flushMicrotasks()
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith("[Task#constructor] startTask failed:", boom)
+			startTaskSpy.mockRestore()
+		})
+
+		it("logs (instead of crashing) when resumeTaskFromHistory rejects from the constructor", async () => {
+			const boom = new Error("resume boom")
+			const resumeSpy = vi
+				.spyOn(Task.prototype as any, "resumeTaskFromHistory")
+				.mockImplementation(async () => {
+					throw boom
+				})
+
+			new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				historyItem: {
+					id: "123",
+					number: 0,
+					ts: Date.now(),
+					task: "historical task",
+					tokensIn: 100,
+					tokensOut: 200,
+					cacheWrites: 0,
+					cacheReads: 0,
+					totalCost: 0.001,
+				},
+				startTask: true,
+			})
+
+			expect(resumeSpy).toHaveBeenCalledTimes(1)
+			await flushMicrotasks()
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith("[Task#constructor] resumeTaskFromHistory failed:", boom)
+			resumeSpy.mockRestore()
+		})
+
+		it("logs (instead of crashing) when postStateToWebviewWithoutTaskHistory rejects from the queue handler", async () => {
+			const boom = new Error("postState boom")
+			mockProvider.postStateToWebviewWithoutTaskHistory = vi.fn().mockRejectedValue(boom)
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			// Triggers messageQueueStateChangedHandler -> void postStateToWebviewWithoutTaskHistory()
+			task.messageQueueService.addMessage("queued text")
+			await flushMicrotasks()
+
+			expect(mockProvider.postStateToWebviewWithoutTaskHistory).toHaveBeenCalled()
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"[Task#messageQueueStateChangedHandler] postStateToWebviewWithoutTaskHistory failed:",
+				boom,
+			)
+		})
+
+		it("logs (instead of crashing) when startTask rejects from start()", async () => {
+			const boom = new Error("start() boom")
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			vi.spyOn(task as any, "startTask").mockImplementation(async () => {
+				throw boom
+			})
+
+			task.start()
+			await flushMicrotasks()
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith("[Task#start] startTask failed:", boom)
+		})
+
+		it("swallows the expected abort rejection from presentAssistantMessageSafe", async () => {
+			const assistantMessageModule = await import("../../assistant-message")
+			const presentSpy = vi
+				.spyOn(assistantMessageModule, "presentAssistantMessage")
+				.mockRejectedValue(new Error("[Task#presentAssistantMessage] task t.i aborted"))
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			// Drain any unrelated console.error noise emitted by async constructor side effects
+			// (CloudService/getState complaints in the test harness) so we only assert on the
+			// abort-path behavior under test.
+			await flushMicrotasks()
+			consoleErrorSpy.mockClear()
+
+			task.abort = true
+			;(task as any).presentAssistantMessageSafe()
+			await flushMicrotasks()
+
+			expect(presentSpy).toHaveBeenCalledTimes(1)
+			const presentErrors = consoleErrorSpy.mock.calls.filter(
+				(call) => typeof call[0] === "string" && call[0].includes("[Task#presentAssistantMessage]"),
+			)
+			expect(presentErrors).toHaveLength(0)
+		})
+
+		it("logs non-abort rejections from presentAssistantMessageSafe", async () => {
+			const assistantMessageModule = await import("../../assistant-message")
+			const boom = new Error("present boom")
+			const presentSpy = vi
+				.spyOn(assistantMessageModule, "presentAssistantMessage")
+				.mockRejectedValue(boom)
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			expect(task.abort).toBeFalsy()
+			;(task as any).presentAssistantMessageSafe()
+			await flushMicrotasks()
+
+			expect(presentSpy).toHaveBeenCalledTimes(1)
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				expect.stringContaining("[Task#presentAssistantMessage] task"),
+				boom,
+			)
+		})
+	})
 })
 
 describe("Queued message processing after condense", () => {