fix(write-to-file): address partial filesystem error review

Author: easonliang28

src/core/task/Task.ts

@@ -1832,18 +1832,36 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 	}
 
 	/**
-		* Finalize the last partial "tool" ask message without blocking for user input.
-		* Call this in error paths where a partial tool message was opened during streaming
-		* but execution failed before the normal approval flow could close it, so the webview
-		* spinner does not get stuck in a loading state.
-		*/
-	async finalizePartialToolAsk(): Promise<void> {
-		const lastMessage = this.clineMessages.at(-1)
-
-		if (lastMessage && lastMessage.partial && lastMessage.type === "ask" && lastMessage.ask === "tool") {
-			lastMessage.partial = false
-			await this.updateClineMessage(lastMessage)
+	 * Finalize a partial "tool" ask message without blocking for user input.
+	 * Call this in error paths where a partial tool message was opened during streaming
+	 * but execution failed before the normal approval flow could close it, so the webview
+	 * spinner does not get stuck in a loading state.
+	 *
+	 * The matching partial message may no longer be the final entry if another asynchronous
+	 * message was inserted between the partial ask and the error handler, so search backward
+	 * instead of relying on clineMessages.at(-1).
+	 */
+	async finalizePartialToolAsk(text?: string): Promise<void> {
+		const partialToolAsk = this.clineMessages
+			.slice()
+			.reverse()
+			.find(
+				(message) =>
+					message.partial === true &&
+					message.type === "ask" &&
+					message.ask === "tool" &&
+					(text === undefined || message.text === text),
+			)
+
+		if (!partialToolAsk) {
+			return
 		}
+
+		partialToolAsk.partial = false
+		await this.saveClineMessages()
+		await this.updateClineMessage(partialToolAsk).catch((error) => {
+			console.error("[Task#finalizePartialToolAsk] updateClineMessage failed:", error)
+		})
 	}
 
 	// Lifecycle

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

@@ -2857,6 +2857,78 @@ describe("Cline", () => {
 			saveSpy.mockRestore()
 		})
 
+		it("finalizePartialToolAsk persists and updates a non-last partial tool ask", async () => {
+			const updateSpy = vi
+				.spyOn(getTaskTestAccess(Task.prototype), "updateClineMessage")
+				.mockResolvedValue(undefined)
+			const saveSpy = vi.spyOn(getTaskTestAccess(Task.prototype), "saveClineMessages").mockResolvedValue(true)
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			const partialToolAsk = {
+				ts: Date.now() - 2,
+				type: "ask" as const,
+				ask: "tool" as const,
+				text: "partial tool message",
+				partial: true,
+			}
+
+			task.clineMessages.push(partialToolAsk)
+			task.clineMessages.push({
+				ts: Date.now() - 1,
+				type: "say",
+				say: "error",
+				text: "intervening async message",
+			})
+
+			await task.finalizePartialToolAsk("partial tool message")
+			await flushMicrotasks()
+
+			expect(partialToolAsk.partial).toBe(false)
+			expect(saveSpy).toHaveBeenCalled()
+			expect(updateSpy).toHaveBeenCalledWith(partialToolAsk)
+
+			updateSpy.mockRestore()
+			saveSpy.mockRestore()
+		})
+
+		it("finalizePartialToolAsk ignores non-matching partial tool asks when text is provided", async () => {
+			const updateSpy = vi
+				.spyOn(getTaskTestAccess(Task.prototype), "updateClineMessage")
+				.mockResolvedValue(undefined)
+			const saveSpy = vi.spyOn(getTaskTestAccess(Task.prototype), "saveClineMessages").mockResolvedValue(true)
+
+			const task = new Task({
+				provider: mockProvider,
+				apiConfiguration: mockApiConfig,
+				task: "test task",
+				startTask: false,
+			})
+
+			task.clineMessages.push({
+				ts: Date.now() - 1,
+				type: "ask",
+				ask: "tool",
+				text: "other partial tool message",
+				partial: true,
+			})
+
+			await task.finalizePartialToolAsk("target partial tool message")
+			await flushMicrotasks()
+
+			expect(task.clineMessages[0].partial).toBe(true)
+			expect(saveSpy).not.toHaveBeenCalled()
+			expect(updateSpy).not.toHaveBeenCalled()
+
+			updateSpy.mockRestore()
+			saveSpy.mockRestore()
+		})
+
 		it("logs (instead of crashing) when updateClineMessage rejects from the ask() ignore-partial path", async () => {
 			// Pins the .catch arm on the fire-and-forget updateClineMessage call
 			// in ask() when a new partial ask arrives while the previous partial

src/core/task/__tests__/Task.throttle.test.ts

@@ -64,10 +64,12 @@ describe("Task token usage throttling", () => {
 	let mockProvider: any
 	let mockApiConfiguration: ProviderSettings
 	let task: Task
+	let consoleLogSpy: ReturnType<typeof vi.spyOn>
 
 	beforeEach(() => {
 		// Reset all mocks
 		vi.clearAllMocks()
+		consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {})
 		vi.useFakeTimers()
 
 		// Mock provider
@@ -101,6 +103,7 @@ describe("Task token usage throttling", () => {
 		if (task && !task.abort) {
 			task.dispose()
 		}
+		consoleLogSpy.mockRestore()
 	})
 
 	test("should emit TaskTokenUsageUpdated immediately on first change", async () => {

src/core/tools/WriteToFileTool.ts

@@ -27,22 +27,47 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 	readonly name = "write_to_file" as const
 
 	/**
-	 * Set when a filesystem error aborts diff-view streaming during handlePartial for the
-	 * current tool invocation. Subsequent streaming deltas for the same block then skip the
-	 * doomed open()/update() retry, which would otherwise create a fresh "Zoo wants to edit
-	 * this file" message on every delta. Cleared by resetPartialState() between invocations.
+	 * Tracks filesystem failures from diff-view streaming by task id. Tool instances are
+	 * singletons, so this state must be keyed per task to avoid one task's failing partial
+	 * stream suppressing another task's streaming deltas.
 	 */
-	private partialStreamFailed = false
+	private partialStreamFailuresByTaskId = new Set<string>()
+
+	/**
+	 * Tracks partial path stabilization by task id. The tool is a singleton, so using the
+	 * BaseTool singleton path state lets concurrent tasks incorrectly stabilize each other.
+	 */
+	private lastSeenPartialPathByTaskId = new Map<string, string | undefined>()
+
+	private getPartialStreamFailureKey(task: Task): string {
+		return `${task.taskId}.${task.instanceId}`
+	}
+
+	private hasPathStabilizedForTask(task: Task, partialPath: string | undefined): boolean {
+		const key = this.getPartialStreamFailureKey(task)
+		const lastSeenPath = this.lastSeenPartialPathByTaskId.get(key)
+		const pathHasStabilized = lastSeenPath !== undefined && lastSeenPath === partialPath
+		this.lastSeenPartialPathByTaskId.set(key, partialPath)
+		return pathHasStabilized && !!partialPath
+	}
+
+	private resetTaskPartialState(task: Task): void {
+		const key = this.getPartialStreamFailureKey(task)
+		this.lastSeenPartialPathByTaskId.delete(key)
+		this.partialStreamFailuresByTaskId.delete(key)
+	}
 
 	override resetPartialState(): void {
 		super.resetPartialState()
-		this.partialStreamFailed = false
+		this.partialStreamFailuresByTaskId.clear()
+		this.lastSeenPartialPathByTaskId.clear()
 	}
 
 	async execute(params: WriteToFileParams, task: Task, callbacks: ToolCallbacks): Promise<void> {
 		const { pushToolResult, handleError, askApproval } = callbacks
 		const relPath = params.path
 		let newContent = params.content
+		const partialStreamFailureKey = this.getPartialStreamFailureKey(task)
 
 		if (!relPath) {
 			task.consecutiveMistakeCount++
@@ -104,15 +129,15 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 		}
 
 		try {
-			task.consecutiveMistakeCount = 0
-
 			// Create parent directories for new files inside the try block so filesystem
 			// errors (EROFS, EACCES, etc.) route through handleError with proper cleanup
 			// and consecutive-mistake counting, rather than escaping unhandled.
 			if (!fileExists) {
 				await createDirectoriesForFile(absolutePath)
 			}
 
+			task.consecutiveMistakeCount = 0
+
 			const provider = task.providerRef.deref()
 			const state = await provider?.getState()
 			const diagnosticsEnabled = state?.diagnosticsEnabled ?? true
@@ -194,7 +219,7 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 			pushToolResult(message)
 
 			await task.diffViewProvider.reset()
-			this.resetPartialState()
+			this.resetTaskPartialState(task)
 
 			task.processQueuedMessages()
 
@@ -207,7 +232,7 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 			await task.finalizePartialToolAsk()
 			await handleError("writing file", error as Error)
 			await task.diffViewProvider.reset()
-			this.resetPartialState()
+			this.resetTaskPartialState(task)
 			return
 		}
 	}
@@ -216,15 +241,17 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 		const relPath: string | undefined = block.params.path
 		const newContent: string | undefined = block.params.content
 
-		// A prior streaming delta for this invocation already hit a fatal filesystem error.
+		const partialStreamFailureKey = this.getPartialStreamFailureKey(task)
+
+		// A prior streaming delta for this task already hit a fatal filesystem error.
 		// Skip further streaming work so we don't create a new partial tool message on every
 		// subsequent delta. execute() will report the error once when the block completes.
-		if (this.partialStreamFailed) {
+		if (this.partialStreamFailuresByTaskId.has(partialStreamFailureKey)) {
 			return
 		}
 
 		// Wait for path to stabilize before showing UI (prevents truncated paths)
-		if (!this.hasPathStabilized(relPath) || newContent === undefined) {
+		if (!this.hasPathStabilizedForTask(task, relPath) || newContent === undefined) {
 			return
 		}
 
@@ -286,9 +313,11 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 				console.error(`Error streaming write_to_file diff view:`, error)
 				// Mark the stream as failed so later deltas don't re-attempt and spawn a new
 				// partial tool message each time.
-				this.partialStreamFailed = true
-				await task.finalizePartialToolAsk()
-				await task.diffViewProvider.reset()
+				this.partialStreamFailuresByTaskId.add(partialStreamFailureKey)
+				await task.finalizePartialToolAsk(partialMessage)
+				await task.diffViewProvider.reset().catch((resetError) => {
+					console.error("Error resetting write_to_file diff view after partial failure:", resetError)
+				})
 			}
 		}
 	}

src/core/tools/__tests__/writeToFileTool.spec.ts

@@ -128,6 +128,8 @@ describe("writeToFileTool", () => {
 			return content
 		})
 
+		mockCline.taskId = "task-1"
+		mockCline.instanceId = "instance-1"
 		mockCline.cwd = "/"
 		mockCline.consecutiveMistakeCount = 0
 		mockCline.didEditFile = false
@@ -421,6 +423,25 @@ describe("writeToFileTool", () => {
 			expect(mockCline.diffViewProvider.open).toHaveBeenCalledWith(testFilePath)
 			expect(mockCline.diffViewProvider.update).toHaveBeenCalledWith(testContent, false)
 		})
+		it("does not share path stabilization between tasks with the same path", async () => {
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			expect(mockCline.ask).not.toHaveBeenCalled()
+
+			mockCline.taskId = "task-2"
+			mockCline.instanceId = "instance-2"
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			expect(mockCline.ask).not.toHaveBeenCalled()
+
+			mockCline.taskId = "task-1"
+			mockCline.instanceId = "instance-1"
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			expect(mockCline.ask).toHaveBeenCalledTimes(1)
+
+			mockCline.taskId = "task-2"
+			mockCline.instanceId = "instance-2"
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			expect(mockCline.ask).toHaveBeenCalledTimes(2)
+		})
 	})
 
 	describe("user interaction", () => {
@@ -562,6 +583,63 @@ describe("writeToFileTool", () => {
 			expect(mockHandleError).toHaveBeenCalledWith("writing file", expect.any(Error))
 		})
 
+		it("does not reset consecutive mistake count when directory creation fails", async () => {
+			mockCline.consecutiveMistakeCount = 3
+			mockedCreateDirectoriesForFile.mockRejectedValue(
+				Object.assign(new Error("EACCES: permission denied, mkdir '/ro'"), { code: "EACCES" }),
+			)
+
+			await executeWriteFileTool({}, { fileExists: false })
+
+			expect(mockHandleError).toHaveBeenCalledWith("writing file", expect.any(Error))
+			expect(mockCline.consecutiveMistakeCount).toBe(3)
+		})
+
+		it("keeps partial stream failures isolated per task", async () => {
+			mockCline.diffViewProvider.open.mockRejectedValueOnce(
+				Object.assign(new Error("EROFS: read-only file system, mkdir '/task-a'"), { code: "EROFS" }),
+			)
+
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			expect(mockCline.ask).toHaveBeenCalledTimes(1)
+
+			mockCline.taskId = "task-2"
+			mockCline.instanceId = "instance-2"
+			mockCline.diffViewProvider.open.mockResolvedValue(undefined)
+			mockCline.diffViewProvider.update.mockResolvedValue(undefined)
+			mockCline.diffViewProvider.editType = undefined
+
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			expect(mockCline.ask).toHaveBeenCalledTimes(1)
+
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+
+			expect(mockCline.ask).toHaveBeenCalledTimes(2)
+			expect(mockCline.diffViewProvider.open).toHaveBeenCalledTimes(2)
+		})
+
+		it("swallows diff view reset errors during partial failure cleanup", async () => {
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+			mockCline.diffViewProvider.open.mockRejectedValue(
+				Object.assign(new Error("EROFS: read-only file system, mkdir '/scratch'"), { code: "EROFS" }),
+			)
+			mockCline.diffViewProvider.reset.mockRejectedValue(new Error("reset failed"))
+
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+			await executeWriteFileTool({}, { fileExists: false, isPartial: true })
+
+			expect(mockCline.finalizePartialToolAsk).toHaveBeenCalled()
+			expect(mockCline.diffViewProvider.reset).toHaveBeenCalled()
+			expect(mockHandleError).not.toHaveBeenCalled()
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Error resetting write_to_file diff view after partial failure:",
+				expect.any(Error),
+			)
+
+			consoleErrorSpy.mockRestore()
+		})
+
 		it.skipIf(process.platform === "win32")(
 			"EROFS in handlePartial does not stall agent loop -- createDirectoriesForFile is not called",
 			async () => {