fix(Task): match the abort error message in presentAssistantMessageSafe

The helper's catch handler was distinguishing abort from real
failures via `this.abort` state at catch time, which has a real
TOCTOU window: a non-abort throw followed by an abort flip
between throw and catch microtask would silently swallow the
real error.

Switched to matching `error.message.endsWith("aborted")` —
the literal contract presentAssistantMessage itself throws on
abort. Same suppression for the abort case, no swallow window
for real errors.

Added a test that pins the message-based discriminator: a
non-abort error with `this.abort = true` now correctly logs
(would have been swallowed under the state-based check). Also
added a regression test for the abort-message-match path so a
future refactor can't drift back to the state check.

Author: 0xMink

src/core/task/Task.ts

@@ -370,7 +370,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	 */
 	private presentAssistantMessageSafe(): void {
 		void presentAssistantMessage(this).catch((error) => {
-			if (this.abort) {
+			// Discriminate on the error message rather than `this.abort` state,
+			// which can flip between the throw and the catch microtask running:
+			// a real failure followed by an abort flip would otherwise be
+			// silently swallowed, and a stale abort error logged as a failure.
+			// The abort throw site in presentAssistantMessage emits a message
+			// ending in "aborted" (matching the other abort-throw contracts in
+			// this file), so we suppress exactly that.
+			if (error instanceof Error && error.message.endsWith("aborted")) {
 				return
 			}
 			console.error(`[Task#presentAssistantMessage] task ${this.taskId}.${this.instanceId} failed:`, error)
@@ -544,7 +551,10 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				.deref()
 				?.postStateToWebviewWithoutTaskHistory()
 				.catch((error) => {
-					console.error("[Task#messageQueueStateChangedHandler] postStateToWebviewWithoutTaskHistory failed:", error)
+					console.error(
+						"[Task#messageQueueStateChangedHandler] postStateToWebviewWithoutTaskHistory failed:",
+						error,
+					)
 				})
 		}
 

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

@@ -1774,11 +1774,9 @@ describe("Cline", () => {
 
 		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
-				})
+			const startTaskSpy = vi.spyOn(Task.prototype as any, "startTask").mockImplementation(async () => {
+				throw boom
+			})
 
 			new Task({
 				provider: mockProvider,
@@ -1796,11 +1794,9 @@ describe("Cline", () => {
 
 		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
-				})
+			const resumeSpy = vi.spyOn(Task.prototype as any, "resumeTaskFromHistory").mockImplementation(async () => {
+				throw boom
+			})
 
 			new Task({
 				provider: mockProvider,
@@ -1900,9 +1896,7 @@ describe("Cline", () => {
 		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 presentSpy = vi.spyOn(assistantMessageModule, "presentAssistantMessage").mockRejectedValue(boom)
 
 			const task = new Task({
 				provider: mockProvider,
@@ -1921,6 +1915,67 @@ describe("Cline", () => {
 				boom,
 			)
 		})
+
+		it("logs a non-abort error even when this.abort flips true after the throw", async () => {
+			// Pins that the message-based discriminator is load-bearing, not the
+			// state check. Under the previous `if (this.abort) return` guard this
+			// case (a genuine downstream failure racing with an abort flip between
+			// the throw and the catch microtask) would silently swallow the error.
+			const assistantMessageModule = await import("../../assistant-message")
+			const realError = new Error("genuine downstream failure")
+			const presentSpy = vi.spyOn(assistantMessageModule, "presentAssistantMessage").mockRejectedValue(realError)
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			await flushMicrotasks()
+			consoleErrorSpy.mockClear()
+
+			// Simulate the TOCTOU race: abort flips between throw and catch.
+			task.abort = true
+			;(task as any).presentAssistantMessageSafe()
+			await flushMicrotasks()
+
+			expect(presentSpy).toHaveBeenCalledTimes(1)
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				expect.stringContaining("[Task#presentAssistantMessage] task"),
+				realError,
+			)
+		})
+
+		it("suppresses an abort-pattern error by message match even when this.abort is false", async () => {
+			// Pins the inverse: message wins over state. A stale abort rejection
+			// arriving before `this.abort` has been observed as true must still be
+			// suppressed, so the catch handler never logs the expected
+			// cancellation rejection as a real failure.
+			const assistantMessageModule = await import("../../assistant-message")
+			const abortError = new Error("[Task#presentAssistantMessage] task t.i aborted")
+			const presentSpy = vi.spyOn(assistantMessageModule, "presentAssistantMessage").mockRejectedValue(abortError)
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			await flushMicrotasks()
+			consoleErrorSpy.mockClear()
+
+			expect(task.abort).toBeFalsy()
+			;(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)
+		})
 	})
 })