Retry transient virtual environment removal failures

Retry recoverable filesystem errors inside the validated deletion operation without weakening integration assertions. Preserve error reporting and environment tracking on final failure, with deterministic regression coverage.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: StellaHuang95

src/managers/builtin/venvUtils.ts

@@ -825,7 +825,7 @@ export async function removeVenv(
             },
             async () => {
                 try {
-                    await fsapi.remove(envPath);
+                    await fsapi.rm(envPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
                     await backends.uv.untrackEnvironment(environment.environmentPath.fsPath);
                     await backends.venv.untrackEnvironment(environment.environmentPath.fsPath);
                     return true;

src/test/managers/builtin/venvUtils.removeVenv.unit.test.ts

@@ -1,8 +1,9 @@
 import * as assert from 'assert';
-import * as fse from 'fs-extra';
+import fse from 'fs-extra';
 import * as os from 'os';
 import * as path from 'path';
 import * as sinon from 'sinon';
+import { Uri } from 'vscode';
 import { Common } from '../../../common/localize';
 import * as windowApis from '../../../common/window.apis';
 import * as uvEnvironments from '../../../managers/builtin/uvEnvironments';
@@ -155,10 +156,11 @@ suite('venvUtils removeVenv validation integration', () => {
         );
     });
 
-    test('headless removal skips confirmation and removes the environment', async () => {
+    test('headless removal skips confirmation and removes the environment with bounded filesystem retries', async () => {
         const tempRoot = await fse.mkdtemp(path.join(os.tmpdir(), 'remove-venv-'));
         const envPath = path.join(tempRoot, '.venv');
         await fse.outputFile(path.join(envPath, 'pyvenv.cfg'), 'home = base');
+        const rmSpy = sinon.spy(fse, 'rm');
         const showWarningMessageStub = sinon.stub(windowApis, 'showWarningMessage');
         sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => task({} as never, {} as never));
         sinon.stub(uvEnvironments, 'removeUvEnvironment').resolves();
@@ -172,10 +174,45 @@ suite('venvUtils removeVenv validation integration', () => {
 
             assert.strictEqual(removed, true);
             assert.strictEqual(showWarningMessageStub.callCount, 0);
+            sinon.assert.calledOnce(rmSpy);
+            const [removedPath, rmOptions] = rmSpy.firstCall.args;
+            assert.ok(typeof removedPath === 'string');
+            assert.strictEqual(Uri.file(removedPath).fsPath, Uri.file(envPath).fsPath);
+            assert.deepStrictEqual(rmOptions, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
             assert.strictEqual(await fse.pathExists(envPath), false);
         } finally {
             sinon.restore();
-            await fse.remove(tempRoot);
+            await fse.rm(tempRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+        }
+    });
+
+    test('failed filesystem removal reports an error without untracking the environment', async () => {
+        const tempRoot = await fse.mkdtemp(path.join(os.tmpdir(), 'remove-venv-failed-'));
+        const envPath = path.join(tempRoot, '.venv');
+        await fse.outputFile(path.join(envPath, 'pyvenv.cfg'), 'home = base');
+        const error = Object.assign(new Error('Environment executable is still locked'), { code: 'EPERM' });
+        const rmStub = sinon.stub(fse, 'rm').rejects(error);
+        const untrackStub = sinon.stub(uvEnvironments, 'removeUvEnvironment').resolves();
+        const showErrorMessageStub = sinon.stub(windowApis, 'showErrorMessage').resolves(undefined);
+        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => task({} as never, {} as never));
+        const log = createMockLogOutputChannel();
+
+        try {
+            const removed = await removeVenv(
+                createMockPythonEnvironment({ name: '.venv', envPath }),
+                log,
+                { runHeadless: true },
+            );
+
+            assert.strictEqual(removed, false);
+            sinon.assert.calledOnce(rmStub);
+            sinon.assert.notCalled(untrackStub);
+            sinon.assert.calledOnce(log.error as sinon.SinonStub);
+            sinon.assert.calledOnce(showErrorMessageStub);
+            assert.strictEqual(await fse.pathExists(envPath), true);
+        } finally {
+            sinon.restore();
+            await fse.rm(tempRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
         }
     });