fix(integrations): never adopt an autosaved match for an unauthorized edit

Series alignment with fws/u6-apply-patch-wiring. The autosave adoption branch accepted ANY
GuardRejectedError when the buffer was clean. An "edit" save with no pre-open observation
is rejected by the unobserved-edit guard - an authorization verdict, not a moved-token
verdict - so if VS Code autosave had already written the buffer, adoption reported success
AND recorded a partial observation for a file the model never read, which would then
authorize a later targeted publish. Adoption is now limited to saves that were authorized
before open().

Also removes the dead committed flag in safeWriteText (declared and set, never read) and
corrects the comment describing a backup-restore guard that does not exist: the backup is
a copy and is never restored.

Author: easonLiangWorldedtech

src/integrations/editor/DiffViewProvider.ts

@@ -561,6 +561,11 @@ export class DiffViewProvider {
 				error instanceof GuardRejectedError &&
 				saveTask &&
 				encodedContent &&
+				// An edit with no pre-open observation was rejected for AUTHORIZATION, not for a
+				// moved token. Adopting the match would report success and record a partial
+				// observation for a file the model never read, which would then authorize a
+				// later edit publish - exactly what the unobserved-edit guard exists to prevent.
+				!(writeKind === "edit" && this.preOpenObservation === null) &&
 				// Only the autosave shape: a clean buffer means its content is what autosave
 				// already put on disk. A dirty buffer means the disk content came from
 				// someone else, so the discard cleanup below is still the right outcome.

src/integrations/editor/__tests__/DiffViewProvider.spec.ts

@@ -2328,6 +2328,39 @@ describe("DiffViewProvider", () => {
 			expect(diffViewProvider["closeAllDiffViews"]).toHaveBeenCalled()
 		})
 
+		it("does not adopt an autosaved match for an edit that was never authorized", async () => {
+			// Same autosave shape, different verdict: with no observation from before open()
+			// the guard rejects for AUTHORIZATION. Adopting the byte match would report a
+			// modified result and record a partial observation for a file the model never
+			// read, which would then authorize a later targeted publish.
+			const cleanEditor = {
+				document: {
+					uri: { fsPath: `${mockCwd}/test.ts`, scheme: "file" },
+					getText: vi.fn().mockReturnValue("new content"),
+					lineCount: 0,
+					encoding: "utf8",
+					isDirty: false,
+					save: vi.fn().mockResolvedValue(undefined),
+				},
+				selection: { active: { line: 0, character: 0 }, anchor: { line: 0, character: 0 } },
+				edit: vi.fn().mockResolvedValue(true),
+				revealRange: vi.fn(),
+			} as unknown as vscode.TextEditor
+			diffViewProvider["activeDiffEditor"] = cleanEditor
+			diffViewProvider.editType = "modify"
+			diffViewProvider["preOpenObservation"] = null
+			mockTask.observationRegistry.clear()
+			vi.mocked(computeVersionToken).mockResolvedValue("moved")
+			vi.mocked(fs.stat).mockResolvedValue(previewStats)
+			vi.mocked(fs.readFile).mockResolvedValue("new content")
+
+			await expect(diffViewProvider.saveChanges(false, 0, "edit")).rejects.toThrow(/File not read yet/)
+
+			// No adoption read, and no observation granted.
+			expect(fs.readFile).not.toHaveBeenCalled()
+			expect(mockTask.observationRegistry.get(`${mockCwd}/test.ts`)).toBeUndefined()
+		})
+
 		it("still rejects when the disk content does not match what the save intended", async () => {
 			// Same autosave shape, different bytes: the guard verdict stands.
 			const cleanEditor = {

src/services/file-safety/safeWriteText.ts

@@ -300,10 +300,6 @@ export async function safeWriteText(
 
 	let backupPath: string | null = null
 	let releaseBackupOnSuccess = false
-	// Set once the commit rename has published the new content. After that point the
-	// backup is no longer a safe restore source: rolling it back would overwrite
-	// content the caller can already observe at the target path.
-	let committed = false
 	// Non-null only when the win32 step-2 block saved a successful DACL dump:
 	// it gates the step-5 restore and is tracked for the cleanup unlinks.
 	let daclDumpPath: string | null = null
@@ -482,7 +478,6 @@ export async function safeWriteText(
 
 			// -- Step 4: atomic rename temp -> target ---------------------
 			await fs.rename(tempPath, targetPath)
-			committed = true
 
 			// -- Step 4b (POSIX): fsync the parent directory so the directory entry
 			// changed by the commit rename is durable, not just the file content.
@@ -548,9 +543,8 @@ export async function safeWriteText(
 			await fs.rmdir(stagingDir).catch(() => {})
 		}
 	} catch (originalError: unknown) {
-		// Only a pre-commit failure can restore the backup. Once the commit rename
-		// published, a later failure (for example the post-commit directory fsync)
-		// must not overwrite the published content with the old file.
+		// The backup is never restored: it is a copy, and the target already holds
+		// either the pre-write content (before the commit) or the published content.
 		if (backupPath && releaseBackupOnSuccess) {
 			// Nothing to restore: the backup is a copy, so the target still holds whatever
 			// the commit left there - before the commit that is the pre-write content, and