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()
+		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/tools/WriteToFileTool.ts

@@ -27,22 +27,26 @@ 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>()
+
+	private getPartialStreamFailureKey(task: Task): string {
+		return `${task.taskId}.${task.instanceId}`
+	}
 
 	override resetPartialState(): void {
 		super.resetPartialState()
-		this.partialStreamFailed = false
+		this.partialStreamFailuresByTaskId.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 +108,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 +198,8 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 			pushToolResult(message)
 
 			await task.diffViewProvider.reset()
-			this.resetPartialState()
+			super.resetPartialState()
+			this.partialStreamFailuresByTaskId.delete(partialStreamFailureKey)
 
 			task.processQueuedMessages()
 
@@ -207,7 +212,8 @@ export class WriteToFileTool extends BaseTool<"write_to_file"> {
 			await task.finalizePartialToolAsk()
 			await handleError("writing file", error as Error)
 			await task.diffViewProvider.reset()
-			this.resetPartialState()
+			super.resetPartialState()
+			this.partialStreamFailuresByTaskId.delete(partialStreamFailureKey)
 			return
 		}
 	}
@@ -216,10 +222,12 @@ 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
 		}
 
@@ -286,8 +294,8 @@ 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()
+				this.partialStreamFailuresByTaskId.add(partialStreamFailureKey)
+				await task.finalizePartialToolAsk(partialMessage)
 				await task.diffViewProvider.reset()
 			}
 		}

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
@@ -562,6 +564,39 @@ 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(2)
+			expect(mockCline.diffViewProvider.open).toHaveBeenCalledTimes(2)
+		})
+
 		it.skipIf(process.platform === "win32")(
 			"EROFS in handlePartial does not stall agent loop -- createDirectoriesForFile is not called",
 			async () => {