fix(task): preserve lifecycle on state push failures

Log throttled state scheduling and flush failures without dropping message persistence or abort cleanup. Cover Task rejection paths and failures from a pending debounced flush.

Signed-off-by: JunyongParkDev <jun94.park@samsung.com>

Author: JunyongParkDev

src/core/task/Task.ts

@@ -1047,9 +1047,17 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// Unanswered asks must reach the webview before Message listeners can respond against its state.
 		const requiresImmediateState =
 			message.partial === true || (message.type === "ask" && message.isAnswered !== true)
-		await provider?.postStateToWebviewThrottled()
+		try {
+			await provider?.postStateToWebviewThrottled()
+		} catch (error) {
+			console.error("[Task#addToClineMessages] postStateToWebviewThrottled failed:", error)
+		}
 		if (requiresImmediateState) {
-			await provider?.flushPostStateToWebviewThrottled()
+			try {
+				await provider?.flushPostStateToWebviewThrottled()
+			} catch (error) {
+				console.error("[Task#addToClineMessages] flushPostStateToWebviewThrottled failed:", error)
+			}
 		}
 		this.emit(RooCodeEventName.Message, { action: "created", message })
 		await this.saveClineMessages()
@@ -2251,7 +2259,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// Force final token usage update before abort event
 		this.emitFinalTokenUsageUpdate()
 
-		await this.providerRef.deref()?.flushPostStateToWebviewThrottled()
+		try {
+			await this.providerRef.deref()?.flushPostStateToWebviewThrottled()
+		} catch (error) {
+			console.error(
+				`[Task#abortTask] flushPostStateToWebviewThrottled failed for ${this.taskId}.${this.instanceId}:`,
+				error,
+			)
+		}
 
 		this.emit(RooCodeEventName.TaskAborted)
 

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

@@ -1733,6 +1733,49 @@ describe("Cline", () => {
 			expect(messageListener).toHaveBeenCalledWith({ action: "created", message })
 		})
 
+		it("continues the message lifecycle when throttled state scheduling and flushing fail", async () => {
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+			const taskAccess = getTaskTestAccess(task)
+			const postError = new Error("state schedule failed")
+			const flushError = new Error("state flush failed")
+			const postSpy = vi.mocked(mockProvider.postStateToWebviewThrottled).mockRejectedValueOnce(postError)
+			const flushSpy = vi.mocked(mockProvider.flushPostStateToWebviewThrottled).mockRejectedValueOnce(flushError)
+			const saveSpy = vi.spyOn(taskAccess, "saveClineMessages").mockResolvedValue(true)
+			const messageListener = vi.fn()
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+			task.on(RooCodeEventName.Message, messageListener)
+			const message = {
+				ts: 1,
+				type: "ask" as const,
+				ask: "resume_task" as const,
+			}
+
+			await expect(taskAccess.addToClineMessages(message)).resolves.toBeUndefined()
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"[Task#addToClineMessages] postStateToWebviewThrottled failed:",
+				postError,
+			)
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"[Task#addToClineMessages] flushPostStateToWebviewThrottled failed:",
+				flushError,
+			)
+			expect(postSpy).toHaveBeenCalledOnce()
+			expect(flushSpy).toHaveBeenCalledOnce()
+			expect(messageListener).toHaveBeenCalledWith({ action: "created", message })
+			expect(saveSpy).toHaveBeenCalledOnce()
+			expect(postSpy.mock.invocationCallOrder[0]).toBeLessThan(flushSpy.mock.invocationCallOrder[0])
+			expect(flushSpy.mock.invocationCallOrder[0]).toBeLessThan(messageListener.mock.invocationCallOrder[0])
+			expect(messageListener.mock.invocationCallOrder[0]).toBeLessThan(saveSpy.mock.invocationCallOrder[0])
+
+			consoleErrorSpy.mockRestore()
+		})
+
 		it("keeps an already answered ask on the throttled path", async () => {
 			const task = new Task({
 				provider: mockProvider,
@@ -1877,6 +1920,38 @@ describe("Cline", () => {
 			)
 		})
 
+		it("continues abort cleanup when flushing pending state fails", async () => {
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+			const error = new Error("state flush failed")
+			const flushSpy = vi.mocked(mockProvider.flushPostStateToWebviewThrottled).mockRejectedValueOnce(error)
+			const taskAbortedListener = vi.fn()
+			const disposeSpy = vi.spyOn(task, "dispose").mockImplementation(() => {})
+			const saveSpy = vi.spyOn(getTaskTestAccess(task), "saveClineMessages").mockResolvedValue(true)
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+			task.on(RooCodeEventName.TaskAborted, taskAbortedListener)
+
+			await expect(task.abortTask()).resolves.toBeUndefined()
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				`[Task#abortTask] flushPostStateToWebviewThrottled failed for ${task.taskId}.${task.instanceId}:`,
+				error,
+			)
+			expect(task.abort).toBe(true)
+			expect(flushSpy).toHaveBeenCalledOnce()
+			expect(taskAbortedListener).toHaveBeenCalledOnce()
+			expect(disposeSpy).toHaveBeenCalledOnce()
+			expect(saveSpy).toHaveBeenCalledOnce()
+			expect(flushSpy.mock.invocationCallOrder[0]).toBeLessThan(taskAbortedListener.mock.invocationCallOrder[0])
+			expect(taskAbortedListener.mock.invocationCallOrder[0]).toBeLessThan(disposeSpy.mock.invocationCallOrder[0])
+
+			consoleErrorSpy.mockRestore()
+		})
+
 		it("should work with TaskLike interface", async () => {
 			const task = new Task({
 				provider: mockProvider,

src/core/webview/__tests__/ClineProvider.spec.ts

@@ -907,6 +907,24 @@ describe("ClineProvider", () => {
 			)
 		})
 
+		test("handles state post failures while flushing a pending trailing post", async () => {
+			const error = new Error("state post failed")
+			const logSpy = vi.spyOn(provider, "log").mockImplementation(() => {})
+			const postStateSpy = vi
+				.spyOn(provider, "postStateToWebviewWithoutTaskHistory")
+				.mockResolvedValueOnce(undefined)
+				.mockRejectedValueOnce(error)
+
+			await provider.postStateToWebviewThrottled()
+			await provider.postStateToWebviewThrottled()
+			await expect(provider.flushPostStateToWebviewThrottled()).resolves.toBeUndefined()
+
+			expect(postStateSpy).toHaveBeenCalledTimes(2)
+			expect(logSpy).toHaveBeenCalledWith(
+				"[ClineProvider#postStateToWebviewThrottled] Failed to post state: state post failed",
+			)
+		})
+
 		test("cancels pending work on dispose and ignores later schedule or flush calls", async () => {
 			const postStateSpy = vi.spyOn(provider, "postStateToWebviewWithoutTaskHistory").mockResolvedValue(undefined)