diff --git a/src/common/lockfile.apis.ts b/src/common/lockfile.apis.ts
new file mode 100644
index 00000000..1d840905
--- /dev/null
+++ b/src/common/lockfile.apis.ts
@@ -0,0 +1,127 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as crypto from 'crypto';
+import * as fsapi from 'fs-extra';
+import * as path from 'path';
+
+export interface AcquireFileLockOptions {
+    readonly timeoutMs: number;
+    readonly retryIntervalMs: number;
+}
+
+export interface AcquiredFileLock {
+    readonly release: () => Promise<void>;
+    /** Keep the lock and make later acquisition attempts fail immediately. */
+    readonly retain: () => Promise<void>;
+}
+
+type LockState = 'held' | 'released' | 'retained';
+
+/** Acquire an atomic lock released only explicitly; interrupted operations remain locked. */
+export async function acquireFileLock(filePath: string, options: AcquireFileLockOptions): Promise<AcquiredFileLock> {
+    const lockPath = `${path.resolve(filePath)}.lock`;
+    const ownerMarker = path.join(lockPath, `owner-${process.pid}-${crypto.randomBytes(16).toString('hex')}`);
+    const retainedMarker = path.join(lockPath, 'retained');
+    const deadline = Date.now() + options.timeoutMs;
+
+    while (true) {
+        try {
+            await fsapi.mkdir(lockPath);
+            try {
+                await fsapi.writeFile(ownerMarker, '', { flag: 'wx' });
+            } catch (error) {
+                try {
+                    await fsapi.rmdir(lockPath);
+                } catch {
+                    throw createLockError(
+                        'Lock initialization failed and left an owner-less lock directory',
+                        'ELOCKORPHANED',
+                        lockPath,
+                    );
+                }
+                throw error;
+            }
+
+            let state: LockState = 'held';
+            return {
+                retain: async () => {
+                    if (state !== 'held') {
+                        return;
+                    }
+                    state = 'retained';
+                    try {
+                        await fsapi.writeFile(retainedMarker, '', { flag: 'wx' });
+                    } catch (error) {
+                        if (hasErrorCode(error, 'EEXIST')) {
+                            return;
+                        }
+                        try {
+                            await fsapi.rename(ownerMarker, retainedMarker);
+                        } catch (renameError) {
+                            if (!hasErrorCode(renameError, 'EEXIST')) {
+                                throw createLockError(
+                                    'Failed to mark the lock as retained',
+                                    'ERETAINFAILED',
+                                    lockPath,
+                                );
+                            }
+                        }
+                    }
+                },
+                release: async () => {
+                    if (state !== 'held') {
+                        return;
+                    }
+                    state = 'released';
+                    try {
+                        await fsapi.unlink(ownerMarker);
+                    } catch (error) {
+                        if (hasErrorCode(error, 'ENOENT')) {
+                            throw createLockError('Lock ownership was compromised', 'ECOMPROMISED', lockPath);
+                        }
+                        throw error;
+                    }
+                    await fsapi.rmdir(lockPath);
+                },
+            };
+        } catch (error) {
+            if (!hasErrorCode(error, 'EEXIST')) {
+                throw error;
+            }
+            if (await isRetainedLock(lockPath)) {
+                throw createLockError('Lock was retained after an interrupted operation', 'ELOCKRETAINED', lockPath);
+            }
+            if (Date.now() >= deadline) {
+                throw createLockError('Lock is already being held', 'ELOCKED', lockPath);
+            }
+            await delay(Math.min(options.retryIntervalMs, Math.max(0, deadline - Date.now())));
+        }
+    }
+}
+
+async function isRetainedLock(lockPath: string): Promise<boolean> {
+    try {
+        await fsapi.lstat(path.join(lockPath, 'retained'));
+        return true;
+    } catch (error) {
+        if (hasErrorCode(error, 'ENOENT')) {
+            return false;
+        }
+        throw error;
+    }
+}
+
+function hasErrorCode(error: unknown, code: string): boolean {
+    return (
+        typeof error === 'object' && error !== null && 'code' in error && (error as NodeJS.ErrnoException).code === code
+    );
+}
+
+function createLockError(message: string, code: string, lockPath: string): NodeJS.ErrnoException {
+    return Object.assign(new Error(message), { code, path: lockPath });
+}
+
+async function delay(milliseconds: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
diff --git a/src/common/utils/virtualEnvironment.ts b/src/common/utils/virtualEnvironment.ts
new file mode 100644
index 00000000..c581bf52
--- /dev/null
+++ b/src/common/utils/virtualEnvironment.ts
@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as path from 'path';
+import { isWindows } from './platformUtils';
+
+export function getVenvPythonPath(envPath: string): string {
+    return isWindows()
+        ? path.join(envPath, 'Scripts', 'python.exe')
+        : path.join(envPath, 'bin', 'python');
+}
diff --git a/src/managers/builtin/helpers.ts b/src/managers/builtin/helpers.ts
index 911bc603..7fb7062a 100644
--- a/src/managers/builtin/helpers.ts
+++ b/src/managers/builtin/helpers.ts
@@ -73,12 +73,22 @@ export async function runUV(
             spawnOptions.timeout = timeout;
         }
         const proc = spawnProcess('uv', args, spawnOptions);
+        let cancellationRequested = false;
         token?.onCancellationRequested(() => {
-            proc.kill();
+            cancellationRequested = true;
+            try {
+                proc.kill();
+            } catch {
+                // Preserve cancellation when signaling fails.
+            }
             reject(new CancellationError());
         });
 
         proc.on('error', (err) => {
+            if (cancellationRequested) {
+                reject(new CancellationError());
+                return;
+            }
             log?.error(`Error spawning uv: ${err}`);
             reject(new Error(`Error spawning uv: ${err.message}`));
         });
@@ -114,12 +124,22 @@ export async function runPython(
     log?.info(`Running: ${python} ${args.join(' ')}`);
     return new Promise<string>((resolve, reject) => {
         const proc = spawnProcess(python, args, { cwd: cwd, timeout });
+        let cancellationRequested = false;
         token?.onCancellationRequested(() => {
-            proc.kill();
+            cancellationRequested = true;
+            try {
+                proc.kill();
+            } catch {
+                // Preserve cancellation when signaling fails.
+            }
             reject(new CancellationError());
         });
 
         proc.on('error', (err) => {
+            if (cancellationRequested) {
+                reject(new CancellationError());
+                return;
+            }
             log?.error(`Error spawning python: ${err}`);
             reject(new Error(`Error spawning python: ${err.message}`));
         });
diff --git a/src/managers/builtin/venvUtils.ts b/src/managers/builtin/venvUtils.ts
index 4efab305..c0614699 100644
--- a/src/managers/builtin/venvUtils.ts
+++ b/src/managers/builtin/venvUtils.ts
@@ -1,7 +1,16 @@
 import * as fsapi from 'fs-extra';
 import * as os from 'os';
 import * as path from 'path';
-import { l10n, LogOutputChannel, ProgressLocation, QuickPickItem, QuickPickItemKind, ThemeIcon, Uri } from 'vscode';
+import {
+    CancellationError,
+    l10n,
+    LogOutputChannel,
+    ProgressLocation,
+    QuickPickItem,
+    QuickPickItemKind,
+    ThemeIcon,
+    Uri,
+} from 'vscode';
 import { EnvironmentManager, PythonEnvironment, PythonEnvironmentApi, PythonEnvironmentInfo } from '../../api';
 import { ENVS_EXTENSION_ID } from '../../common/constants';
 import { Common, VenvManagerStrings } from '../../common/localize';
@@ -10,6 +19,7 @@ import { getWorkspacePersistentState } from '../../common/persistentState';
 import { EventNames } from '../../common/telemetry/constants';
 import { sendTelemetryEvent } from '../../common/telemetry/sender';
 import { normalizePath } from '../../common/utils/pathUtils';
+import { getVenvPythonPath } from '../../common/utils/virtualEnvironment';
 import {
     showErrorMessage,
     showOpenDialog,
@@ -52,6 +62,9 @@ export interface CreateEnvironmentResult {
      * Exists if error occurred while installing packages and includes error description.
      */
     pkgInstallationErr?: string;
+
+    /** Cancellation may leave package processes running. */
+    pkgInstallationCancelled?: boolean;
 }
 
 export async function clearVenvCache(): Promise<void> {
@@ -340,9 +353,9 @@ export async function createWithProgress(
     venvRoot: Uri,
     envPath: string,
     packages?: PipPackages,
+    trackUvEnvironment = true,
 ): Promise<CreateEnvironmentResult | undefined> {
-    const pythonPath =
-        os.platform() === 'win32' ? path.join(envPath, 'Scripts', 'python.exe') : path.join(envPath, 'bin', 'python');
+    const pythonPath = getVenvPythonPath(envPath);
 
     return await withProgress(
         {
@@ -383,6 +396,7 @@ export async function createWithProgress(
                 const env = api.createPythonEnvironmentItem(await getPythonInfo(resolved), manager);
 
                 if (
+                    trackUvEnvironment &&
                     useUv &&
                     (resolved.kind === NativePythonEnvironmentKind.venvUv ||
                         resolved.kind === NativePythonEnvironmentKind.uvWorkspace)
@@ -401,6 +415,7 @@ export async function createWithProgress(
                     } catch (e) {
                         // error occurred while installing packages
                         result.pkgInstallationErr = e instanceof Error ? e.message : String(e);
+                        result.pkgInstallationCancelled = e instanceof CancellationError;
                     }
                 }
                 result.environment = env;
diff --git a/src/test/common/lockfile.apis.unit.test.ts b/src/test/common/lockfile.apis.unit.test.ts
new file mode 100644
index 00000000..a2d343a1
--- /dev/null
+++ b/src/test/common/lockfile.apis.unit.test.ts
@@ -0,0 +1,212 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import assert from 'assert';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
+import fsExtra from 'fs-extra';
+import * as fs from 'fs-extra';
+import * as os from 'os';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import { acquireFileLock, AcquireFileLockOptions } from '../../common/lockfile.apis';
+
+const OPTIONS: AcquireFileLockOptions = {
+    timeoutMs: 40,
+    retryIntervalMs: 5,
+};
+
+const LOCK_MODULE_PATH = path.resolve(__dirname, '..', '..', 'common', 'lockfile.apis.js');
+
+suite('lockfile APIs', () => {
+    let tempRoot: string;
+    let targetPath: string;
+
+    setup(async () => {
+        tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'python-envs-lock-'));
+        targetPath = path.join(tempRoot, 'cache-entry');
+    });
+
+    teardown(async () => {
+        sinon.restore();
+        await fs.remove(tempRoot);
+    });
+
+    function startLockingChild(exitWithoutRelease: boolean): ChildProcessWithoutNullStreams {
+        const script = `
+            const { acquireFileLock } = require(process.argv[1]);
+            acquireFileLock(process.argv[2], { timeoutMs: 1000, retryIntervalMs: 10 })
+                .then((lock) => {
+                    process.stdout.write('locked\\n');
+                    if (${exitWithoutRelease}) {
+                        process.exit(0);
+                    }
+                    process.stdin.once('data', async () => {
+                        await lock.release();
+                        process.exit(0);
+                    });
+                })
+                .catch((error) => {
+                    process.stderr.write(String(error && error.stack ? error.stack : error));
+                    process.exit(1);
+                });
+        `;
+        return spawn(process.execPath, ['-e', script, LOCK_MODULE_PATH, targetPath]);
+    }
+
+    async function waitForLocked(child: ChildProcessWithoutNullStreams): Promise<void> {
+        await new Promise<void>((resolve, reject) => {
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+                if (stdout.includes('locked')) {
+                    resolve();
+                }
+            });
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.once('error', reject);
+            child.once('exit', (code) => {
+                if (!stdout.includes('locked')) {
+                    reject(new Error(`locking child exited with code ${code}: ${stderr}`));
+                }
+            });
+        });
+    }
+
+    async function waitForExit(child: ChildProcessWithoutNullStreams): Promise<void> {
+        if (child.exitCode !== null) {
+            assert.strictEqual(child.exitCode, 0);
+            return;
+        }
+        await new Promise<void>((resolve, reject) => {
+            child.once('error', reject);
+            child.once('exit', (code) => {
+                if (code === 0) {
+                    resolve();
+                } else {
+                    reject(new Error(`locking child exited with code ${code}`));
+                }
+            });
+        });
+    }
+
+    test('excludes a second owner until the first releases the lock', async () => {
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+        await assert.rejects(acquireFileLock(targetPath, OPTIONS), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ELOCKED';
+        });
+
+        await lock.release();
+        const lockAfterRetry = await acquireFileLock(targetPath, OPTIONS);
+        await lockAfterRetry.release();
+        assert.strictEqual(await fs.pathExists(`${path.resolve(targetPath)}.lock`), false);
+    });
+
+    test('excludes another process until the owner explicitly releases', async () => {
+        const child = startLockingChild(false);
+        await waitForLocked(child);
+
+        await assert.rejects(acquireFileLock(targetPath, OPTIONS), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ELOCKED';
+        });
+
+        child.stdin.write('release\n');
+        await waitForExit(child);
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+        await lock.release();
+    });
+
+    test('leaves the lock fail-closed when the owner process exits without release', async () => {
+        const child = startLockingChild(true);
+        await waitForLocked(child);
+        await waitForExit(child);
+
+        await assert.rejects(acquireFileLock(targetPath, OPTIONS), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ELOCKED';
+        });
+        assert.strictEqual(await fs.pathExists(`${path.resolve(targetPath)}.lock`), true);
+    });
+
+    test('an old release cannot remove a successor lock generation', async () => {
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+        const lockPath = `${path.resolve(targetPath)}.lock`;
+        await fs.remove(lockPath);
+        await fs.ensureDir(lockPath);
+        const successorMarker = path.join(lockPath, 'successor-owner');
+        await fs.writeFile(successorMarker, '');
+
+        await assert.rejects(lock.release(), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ECOMPROMISED';
+        });
+        assert.strictEqual(await fs.pathExists(successorMarker), true);
+    });
+
+    test('release is idempotent', async () => {
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+
+        await lock.release();
+        await lock.release();
+
+        assert.strictEqual(await fs.pathExists(`${path.resolve(targetPath)}.lock`), false);
+    });
+
+    test('retained locks fail fast without waiting for the acquisition timeout', async () => {
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+        await lock.retain();
+        const startedAt = Date.now();
+
+        await assert.rejects(
+            acquireFileLock(targetPath, { timeoutMs: 10_000, retryIntervalMs: 1_000 }),
+            (error: NodeJS.ErrnoException) => error.code === 'ELOCKRETAINED',
+        );
+
+        assert.ok(Date.now() - startedAt < 1_000);
+        const lockPath = `${path.resolve(targetPath)}.lock`;
+        const retainedEntries = await fs.readdir(lockPath);
+        assert.ok(retainedEntries.includes('retained'));
+        assert.strictEqual(retainedEntries.filter((entry) => entry.startsWith('owner-')).length, 1);
+
+        await lock.release();
+        assert.deepStrictEqual(await fs.readdir(lockPath), retainedEntries);
+    });
+
+    test('falls back to renaming the owner marker when the retained sentinel cannot be written', async () => {
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+        sinon.stub(fsExtra, 'writeFile').rejects(Object.assign(new Error('write failed'), { code: 'EACCES' }));
+
+        await lock.retain();
+
+        const lockPath = `${path.resolve(targetPath)}.lock`;
+        assert.deepStrictEqual(await fs.readdir(lockPath), ['retained']);
+        await assert.rejects(acquireFileLock(targetPath, OPTIONS), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ELOCKRETAINED';
+        });
+    });
+
+    test('remains fail-closed when neither retained-marker strategy succeeds', async () => {
+        const lock = await acquireFileLock(targetPath, OPTIONS);
+        sinon.stub(fsExtra, 'writeFile').rejects(Object.assign(new Error('write failed'), { code: 'EACCES' }));
+        sinon.stub(fsExtra, 'rename').rejects(Object.assign(new Error('rename failed'), { code: 'EBUSY' }));
+
+        await assert.rejects(lock.retain(), (error: NodeJS.ErrnoException) => error.code === 'ERETAINFAILED');
+        await lock.release();
+
+        const lockPath = `${path.resolve(targetPath)}.lock`;
+        const lockEntries = await fs.readdir(lockPath);
+        assert.strictEqual(lockEntries.filter((entry) => entry.startsWith('owner-')).length, 1);
+        await assert.rejects(acquireFileLock(targetPath, OPTIONS), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ELOCKED';
+        });
+    });
+
+    test('reports an owner-less lock when initialization cleanup fails', async () => {
+        sinon.stub(fsExtra, 'writeFile').rejects(Object.assign(new Error('write failed'), { code: 'EIO' }));
+        sinon.stub(fsExtra, 'rmdir').rejects(Object.assign(new Error('cleanup failed'), { code: 'EACCES' }));
+
+        await assert.rejects(acquireFileLock(targetPath, OPTIONS), (error: NodeJS.ErrnoException) => {
+            return error.code === 'ELOCKORPHANED' && error.path === `${path.resolve(targetPath)}.lock`;
+        });
+    });
+});
diff --git a/src/test/common/virtualEnvironment.unit.test.ts b/src/test/common/virtualEnvironment.unit.test.ts
new file mode 100644
index 00000000..093ab710
--- /dev/null
+++ b/src/test/common/virtualEnvironment.unit.test.ts
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import assert from 'assert';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import * as platformUtils from '../../common/utils/platformUtils';
+import { getVenvPythonPath } from '../../common/utils/virtualEnvironment';
+
+suite('virtual environment utilities', () => {
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('uses Scripts/python.exe on Windows', () => {
+        sinon.stub(platformUtils, 'isWindows').returns(true);
+        assert.strictEqual(
+            getVenvPythonPath(path.join('cache', 'env')),
+            path.join('cache', 'env', 'Scripts', 'python.exe'),
+        );
+    });
+
+    test('uses bin/python outside Windows', () => {
+        sinon.stub(platformUtils, 'isWindows').returns(false);
+        assert.strictEqual(getVenvPythonPath(path.join('cache', 'env')), path.join('cache', 'env', 'bin', 'python'));
+    });
+});
diff --git a/src/test/managers/builtin/helpers.cancellation.unit.test.ts b/src/test/managers/builtin/helpers.cancellation.unit.test.ts
new file mode 100644
index 00000000..5a458306
--- /dev/null
+++ b/src/test/managers/builtin/helpers.cancellation.unit.test.ts
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import assert from 'assert';
+import * as sinon from 'sinon';
+import { CancellationError, CancellationToken, CancellationTokenSource } from 'vscode';
+import * as childProcessApis from '../../../common/childProcess.apis';
+import { runPython, runUV } from '../../../managers/builtin/helpers';
+import { MockChildProcess } from '../../mocks/mockChildProcess';
+
+suite('process helper cancellation safety', () => {
+    let spawnStub: sinon.SinonStub;
+
+    setup(() => {
+        spawnStub = sinon.stub(childProcessApis, 'spawnProcess');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    async function expectCancellation(
+        process: MockChildProcess,
+        run: (token: CancellationToken) => Promise<string>,
+        killBehavior: 'emitError' | 'throw',
+    ): Promise<void> {
+        spawnStub.returns(process);
+        const killStub = sinon.stub(process, 'kill');
+        if (killBehavior === 'emitError') {
+            killStub.callsFake(() => {
+                process.emit('error', new Error('kill EPERM'));
+                return false;
+            });
+        } else {
+            killStub.throws(new Error('kill EPERM'));
+        }
+
+        const tokenSource = new CancellationTokenSource();
+        const result = run(tokenSource.token);
+        tokenSource.cancel();
+
+        await assert.rejects(result, (error: Error) => {
+            assert.ok(error instanceof CancellationError);
+            return true;
+        });
+        assert.ok(killStub.calledOnce);
+        tokenSource.dispose();
+    }
+
+    test('runUV remains cancelled when kill emits an error synchronously', async () => {
+        const process = new MockChildProcess('uv', ['pip', 'install', 'requests']);
+        await expectCancellation(
+            process,
+            (token) => runUV(['pip', 'install', 'requests'], undefined, undefined, token),
+            'emitError',
+        );
+    });
+
+    test('runUV remains cancelled when kill throws', async () => {
+        const process = new MockChildProcess('uv', ['pip', 'install', 'requests']);
+        await expectCancellation(
+            process,
+            (token) => runUV(['pip', 'install', 'requests'], undefined, undefined, token),
+            'throw',
+        );
+    });
+
+    test('runPython remains cancelled when kill emits an error synchronously', async () => {
+        const process = new MockChildProcess('python', ['-m', 'pip', 'install', 'requests']);
+        await expectCancellation(
+            process,
+            (token) => runPython('python', ['-m', 'pip', 'install', 'requests'], undefined, undefined, token),
+            'emitError',
+        );
+    });
+
+    test('runPython remains cancelled when kill throws', async () => {
+        const process = new MockChildProcess('python', ['-m', 'pip', 'install', 'requests']);
+        await expectCancellation(
+            process,
+            (token) => runPython('python', ['-m', 'pip', 'install', 'requests'], undefined, undefined, token),
+            'throw',
+        );
+    });
+});
diff --git a/src/test/managers/builtin/venvUtils.createWithProgress.unit.test.ts b/src/test/managers/builtin/venvUtils.createWithProgress.unit.test.ts
new file mode 100644
index 00000000..bd8e720e
--- /dev/null
+++ b/src/test/managers/builtin/venvUtils.createWithProgress.unit.test.ts
@@ -0,0 +1,134 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import assert from 'assert';
+import * as fs from 'fs-extra';
+import * as os from 'os';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import { CancellationError, LogOutputChannel, Uri } from 'vscode';
+import { EnvironmentManager, PythonEnvironment, PythonEnvironmentApi } from '../../../api';
+import * as windowApis from '../../../common/window.apis';
+import { getVenvPythonPath } from '../../../common/utils/virtualEnvironment';
+import * as builtinHelpers from '../../../managers/builtin/helpers';
+import * as uvEnvironments from '../../../managers/builtin/uvEnvironments';
+import { createWithProgress } from '../../../managers/builtin/venvUtils';
+import { NativePythonEnvironmentKind, NativePythonFinder } from '../../../managers/common/nativePythonFinder';
+import * as managerUtils from '../../../managers/common/utils';
+
+suite('createWithProgress uv tracking', () => {
+    let addUvEnvironmentStub: sinon.SinonStub;
+    let api: PythonEnvironmentApi;
+    let baseEnvironment: PythonEnvironment;
+    let envPath: string;
+    let log: LogOutputChannel;
+    let manager: EnvironmentManager;
+    let nativeFinder: NativePythonFinder;
+    let tempRoot: string;
+
+    setup(async () => {
+        tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'create-with-progress-'));
+        envPath = path.join(tempRoot, 'env');
+        const pythonPath = getVenvPythonPath(envPath);
+        await fs.outputFile(pythonPath, '');
+
+        baseEnvironment = {
+            envId: { id: 'base', managerId: 'ms-python.python:system' },
+            name: 'base',
+            displayName: 'base',
+            displayPath: pythonPath,
+            version: '3.12.4',
+            environmentPath: Uri.file(pythonPath),
+            execInfo: { run: { executable: pythonPath } },
+            sysPrefix: tempRoot,
+        };
+        const createdEnvironment = {
+            ...baseEnvironment,
+            envId: { id: 'created', managerId: 'ms-python.python:inline-script' },
+        };
+        api = {
+            createPythonEnvironmentItem: sinon.stub().returns(createdEnvironment),
+            managePackages: sinon.stub().resolves(),
+        } as unknown as PythonEnvironmentApi;
+        nativeFinder = {
+            resolve: sinon.stub().resolves({
+                executable: pythonPath,
+                prefix: envPath,
+                version: '3.12.4',
+                kind: NativePythonEnvironmentKind.venvUv,
+            }),
+        } as unknown as NativePythonFinder;
+        log = {
+            error: sinon.stub(),
+            info: sinon.stub(),
+            append: sinon.stub(),
+        } as unknown as LogOutputChannel;
+        manager = { log } as EnvironmentManager;
+
+        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => task({} as never, {} as never));
+        sinon.stub(builtinHelpers, 'shouldUseUv').resolves(true);
+        sinon.stub(builtinHelpers, 'runUV').resolves('');
+        sinon.stub(managerUtils, 'getShellActivationCommands').resolves({
+            shellActivation: new Map(),
+            shellDeactivation: new Map(),
+        });
+        addUvEnvironmentStub = sinon.stub(uvEnvironments, 'addUvEnvironment').resolves();
+    });
+
+    teardown(async () => {
+        sinon.restore();
+        await fs.remove(tempRoot);
+    });
+
+    test('tracks uv environments by default for existing callers', async () => {
+        const result = await createWithProgress(
+            nativeFinder,
+            api,
+            log,
+            manager,
+            baseEnvironment,
+            Uri.file(tempRoot),
+            envPath,
+        );
+
+        assert.ok(result?.environment);
+        assert.ok(addUvEnvironmentStub.calledOnce);
+    });
+
+    test('skips workspace-scoped uv tracking when explicitly disabled', async () => {
+        const result = await createWithProgress(
+            nativeFinder,
+            api,
+            log,
+            manager,
+            baseEnvironment,
+            Uri.file(tempRoot),
+            envPath,
+            undefined,
+            false, // trackUvEnvironment
+        );
+
+        assert.ok(result?.environment);
+        assert.strictEqual(addUvEnvironmentStub.callCount, 0);
+    });
+
+    test('marks cancelled package installation as potentially still mutating', async () => {
+        (api.managePackages as sinon.SinonStub).rejects(new CancellationError());
+
+        const result = await createWithProgress(
+            nativeFinder,
+            api,
+            log,
+            manager,
+            baseEnvironment,
+            Uri.file(tempRoot),
+            envPath,
+            { install: ['requests'], uninstall: [] },
+            false, // trackUvEnvironment
+        );
+
+        assert.ok(result?.environment);
+        assert.strictEqual(typeof result.pkgInstallationErr, 'string');
+        assert.strictEqual(result.pkgInstallationCancelled, true);
+    });
+});