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

@@ -365,7 +365,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)

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

@@ -2513,6 +2513,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)
+		})
 	})
 })