@@ -757,12 +757,17 @@ export class DiffViewProvider {
 			// Only a placeholder THIS edit created may be removed. relPath survives reset(), and
 			// saveDirectly() sets it for a file that was written with approval, so unlinking
 			// absolutePath unconditionally can delete content the user approved.
-			if (placeholderPath) {
-				// The helpers carry the ENOENT tolerance: open() creates the placeholder,
-				// and if it is already gone there is nothing left to remove.
+			// The field names the path open() created empty; it is not proof that this edit
+			// still owns the file. Another provider working the same path can write and save
+			// approved content there while this abandoned session still carries the field, and
+			// unlinking on the field alone deletes that write. The placeholder open() created is
+			// zero bytes, so only a file that is still zero bytes is this edit's to remove - the
+			// ENOENT case and any file with content in it release the ownership and leave the
+			// bytes alone, which is what a later writer's approved write needs.
+			if (placeholderPath && (await fs.stat(placeholderPath).catch(() => null))?.size === 0) {
 				await this.removeCreatedFile(placeholderPath)
-				this.placeholderPath = undefined
 			}
+			this.placeholderPath = undefined
 
 			// Remove only the directories this edit created, in reverse order.
 			for (let i = createdDirs.length - 1; i >= 0; i--) {
 
@@ -23,6 +23,10 @@ vi.mock("fs/promises", () => ({
 	// directories the edit created.
 	unlink: vi.fn().mockResolvedValue(undefined),
 	rmdir: vi.fn().mockResolvedValue(undefined),
+	// The abandoned-stream cleanup stats the placeholder before unlinking it: only the
+	// file open() created empty is its own to delete. The default double reports exactly
+	// that zero-byte placeholder; rows that mean a filled file override it once.
+	stat: vi.fn(async () => ({ size: 0 })),
 }))
 
 // Mock utils
@@ -2576,6 +2580,31 @@ describe("DiffViewProvider", () => {
 			expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("mock-target-file.ts"))
 		})
 
+		it("releases the placeholder instead of unlinking a path another writer filled", async () => {
+			// The field only names the path open() created empty - it does not prove this edit still
+			// owns the file. A second provider working the same path can write and save approved
+			// content into that file while this abandoned session still carries the field, and the
+			// unlink the cleanup used to run unconditionally deletes that approved write. The bytes
+			// are somebody else's now, so only the ownership is released here.
+			const callOrder: string[] = []
+			const document = makeAbandonedDocument(callOrder)
+			openAbandonedView(document, [], callOrder)
+			// 42 bytes on disk: not the empty placeholder this edit created.
+			vi.mocked(fs.stat).mockResolvedValueOnce({ size: 42 } as unknown as fs.Stats)
+			vi.mocked(vscode.workspace.applyEdit).mockResolvedValueOnce(true)
+
+			await diffViewProvider.discardUnapprovedStream()
+
+			// The buffer work still happened (the restore is mocked to resolve, so it is not
+			// recorded in the order list):
+			expect(callOrder).toEqual(["save", "closeDiffViews", "closeFileTab"])
+			// ...but the file with content in it is not unlinked, and the ownership is released so
+			// the caller can reset the session without a later cleanup deleting the write again.
+			expect(fs.unlink).not.toHaveBeenCalled()
+			expect(diffViewProvider["placeholderPath"]).toBeUndefined()
+			expect(diffViewProvider["ownsPlaceholder"]).toBe(false)
+		})
+
 		it("restores a modify buffer in memory and never saves the target file", async () => {
 			// revertChanges() restores a modify by applyEdit + document.save(). For a stream the
 			// user never approved that save is a write they never asked for, and for a