diff --git a/.github/instructions/testing-workflow.instructions.md b/.github/instructions/testing-workflow.instructions.md
index b374c38d1..6079820ad 100644
--- a/.github/instructions/testing-workflow.instructions.md
+++ b/.github/instructions/testing-workflow.instructions.md
@@ -606,3 +606,4 @@ envConfig.inspect
 - **Never skip tests to hide infrastructure problems**: If tests require native binaries (like `pet`), the CI workflow must build/download them. Skipping tests when infrastructure is missing gives false confidence. Build from source (like vscode-python does) rather than skipping. Tests should fail clearly when something is wrong (2)
 - **No retries for masking flakiness**: Mocha `retries` should not be used to mask test flakiness. If a test is flaky, fix the root cause. Retries hide real issues and slow down CI (1)
 - **pet binary is required for environment manager registration**: The smoke/E2E/integration tests require the `pet` binary from `microsoft/python-environment-tools` to be built and placed in `python-env-tools/bin/`. Without it, `waitForApiReady()` will timeout because managers never register. CI must build pet from source using `cargo build --release --package pet` (2)
+- **Package lifecycle integration tests require package-index network access**: Venv quick creation seeds Pip through `uv`, and package roundtrip tests download packages. TLS or connectivity failures to PyPI can make `createEnvironment()` return `undefined` before package assertions run (1)
diff --git a/src/managers/builtin/pipListUtils.ts b/src/managers/builtin/pipListUtils.ts
deleted file mode 100644
index 80519d89d..000000000
--- a/src/managers/builtin/pipListUtils.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { LogOutputChannel } from 'vscode';
-
-export interface PipPackage {
-    name: string;
-    version: string;
-    displayName: string;
-    description: string;
-}
-export function parseUvTree(data: string): string[] {
-    return data
-        .split('\n')
-        .map((line) => line.trim())
-        .map((line) => line.split(/\s+/, 1)[0])
-        .filter((name) => !!name);
-}
-
-export function parsePipListJson(data: string, log?: LogOutputChannel): PipPackage[] {
-    try {
-        const json = JSON.parse(data);
-        if (Array.isArray(json)) {
-            return json
-                .filter((item) => item.name && item.version)
-                .map(({ name, version }) => ({
-                    name,
-                    version,
-                    displayName: name,
-                    description: version,
-                }));
-        }
-    } catch (ex) {
-        log?.error('Failed to parse pip list JSON output', ex);
-    }
-    return [];
-}
diff --git a/src/managers/builtin/pipPackageManager.ts b/src/managers/builtin/pipPackageManager.ts
index f0e09a7d0..82f208b3d 100644
--- a/src/managers/builtin/pipPackageManager.ts
+++ b/src/managers/builtin/pipPackageManager.ts
@@ -1,10 +1,11 @@
 import type { Pep440Version } from '@renovatebot/pep440';
-import { compare, explain as parse, rcompare } from '@renovatebot/pep440';
+import { compare, explain as parse } from '@renovatebot/pep440';
 import {
     CancellationError,
     Disposable,
     Event,
     EventEmitter,
+    l10n,
     LogOutputChannel,
     MarkdownString,
     ProgressLocation,
@@ -21,10 +22,26 @@ import {
     PythonEnvironment,
     PythonEnvironmentApi,
 } from '../../api';
+import { withProgress } from '../../common/window.apis';
+import { CommandConstructorOptions } from '../base/commands/index';
 import { updatePackagesAndNotify } from '../common/packageChanges';
-import { runPython, runUV, shouldUseUv } from './helpers';
+import { createPipOrUvCommand } from './commands/factory';
+import {
+    PipAvailableVersionsCommand,
+    PipInstallCommand,
+    PipListCommand,
+    PipListDirectNamesCommand,
+    PipUninstallCommand,
+    PipVersionCommand,
+    UvAvailableVersionsCommand,
+    UvInstallCommand,
+    UvListCommand,
+    UvListDirectNamesCommand,
+    UvUninstallCommand,
+    UvVersionCommand,
+} from './commands/index';
 import { getWorkspacePackagesToInstall } from './pipUtils';
-import { managePackages, normalizePackageName, refreshPipDirectPackageNames, refreshPipPackages } from './utils';
+import { parsePackageSpecs } from './utils';
 import { VenvManager } from './venvManager';
 
 export class PipPackageManager implements PackageManager, Disposable {
@@ -65,43 +82,76 @@ export class PipPackageManager implements PackageManager, Disposable {
             }
         }
 
-        const manageOptions = {
-            ...options,
-            install: toInstall,
-            uninstall: toUninstall,
-        };
-        await window.withProgress(
-            {
-                location: ProgressLocation.Notification,
-                title: 'Installing packages',
-                cancellable: true,
-            },
-            async (_progress, token) => {
-                try {
-                    await managePackages(environment, manageOptions, this, token);
-                    await updatePackagesAndNotify(
-                        this,
-                        environment,
-                        this.packages.get(environment.envId.id),
-                        (changes) => {
-                            this._onDidChangePackages.fire({ environment, manager: this, changes });
-                        },
-                    );
-                } catch (e) {
-                    if (e instanceof CancellationError) {
-                        throw e;
-                    }
-                    this.log.error('Error managing packages', e);
-                    setImmediate(async () => {
-                        const result = await window.showErrorMessage('Error managing packages', 'View Output');
-                        if (result === 'View Output') {
-                            this.log.show();
-                        }
-                    });
-                    throw e;
+        if (environment.version.startsWith('2.')) {
+            throw new Error('Python 2.* is not supported (deprecated)');
+        }
+
+        try {
+            const pythonExecutable = environment.execInfo?.run?.executable;
+            if (!pythonExecutable) {
+                throw new Error('Unable to determine Python executable path');
+            }
+
+            // Centralize command options for install/uninstall operations
+            const manageCommandOptions: CommandConstructorOptions = {
+                pythonExecutable,
+                log: this.log,
+            };
+
+            // Execute uninstall if needed
+            if (toUninstall.length > 0) {
+                const uninstallCmd: PipUninstallCommand | UvUninstallCommand = await createPipOrUvCommand(
+                    manageCommandOptions,
+                    environment.environmentPath.fsPath,
+                    PipUninstallCommand,
+                    UvUninstallCommand,
+                );
+                const packages = parsePackageSpecs(toUninstall);
+                await withProgress(
+                    {
+                        location: ProgressLocation.Notification,
+                        title: l10n.t('Uninstalling packages'),
+                        cancellable: true,
+                    },
+                    (_progress, token) => uninstallCmd.execute({ packages, cancellationToken: token }),
+                );
+            }
+
+            // Execute install if needed
+            if (toInstall.length > 0) {
+                const installCmd: PipInstallCommand | UvInstallCommand = await createPipOrUvCommand(
+                    manageCommandOptions,
+                    environment.environmentPath.fsPath,
+                    PipInstallCommand,
+                    UvInstallCommand,
+                );
+                const packages = parsePackageSpecs(toInstall);
+                await withProgress(
+                    { location: ProgressLocation.Notification, title: 'Installing packages', cancellable: true },
+                    (_progress, token) =>
+                        installCmd.execute({ packages, upgrade: options.upgrade, cancellationToken: token }),
+                );
+            }
+
+            await updatePackagesAndNotify(this, environment, this.packages.get(environment.envId.id), (changes) => {
+                this._onDidChangePackages.fire({ environment, manager: this, changes });
+            });
+        } catch (e) {
+            if (e instanceof CancellationError) {
+                // Cancellation is a normal control-flow exit; skip the user-facing error
+                // UI/logging, but rethrow so callers can distinguish cancel from failure
+                // (e.g. venv creation sets pkgInstallationCancelled by catching CancellationError).
+                throw e;
+            }
+            this.log.error('Error managing packages', e);
+            setImmediate(async () => {
+                const result = await window.showErrorMessage('Error managing packages', 'View Output');
+                if (result === 'View Output') {
+                    this.log.show();
                 }
-            },
-        );
+            });
+            throw e;
+        }
     }
 
     async refresh(environment: PythonEnvironment): Promise<Package[] | undefined> {
@@ -125,7 +175,20 @@ export class PipPackageManager implements PackageManager, Disposable {
 
     async getPackages(environment: PythonEnvironment, options?: GetPackagesOptions): Promise<Package[] | undefined> {
         if (options?.skipCache || !this.packages.has(environment.envId.id)) {
-            const data = await refreshPipPackages(environment, this.log);
+            const pythonExecutable = environment.execInfo?.run?.executable;
+            if (!pythonExecutable) {
+                return undefined;
+            }
+            const listCmd: PipListCommand | UvListCommand = await createPipOrUvCommand(
+                {
+                    pythonExecutable,
+                    log: this.log,
+                },
+                environment.environmentPath.fsPath,
+                PipListCommand,
+                UvListCommand,
+            );
+            const data = await listCmd.execute();
             const packages = (data ?? []).map((pkg) => this.api.createPackageItem(pkg, environment, this));
             this.packages.set(environment.envId.id, packages);
             return packages;
@@ -135,22 +198,17 @@ export class PipPackageManager implements PackageManager, Disposable {
 
     async getVersion(environment: PythonEnvironment): Promise<Pep440Version | undefined> {
         try {
-            const useUv = await shouldUseUv(this.log, environment.environmentPath.fsPath);
-            if (useUv) {
-                const result = await runUV(['--version'], undefined, this.log);
-                // "uv X.Y.Z"
-                const match = result.match(/^uv\s+(\d+\.\d+(?:\.\d+)*)/);
-                return match ? (parse(match[1]) ?? undefined) : undefined;
+            const pythonExecutable = environment.execInfo?.run?.executable;
+            if (!pythonExecutable) {
+                return undefined;
             }
-            const result = await runPython(
-                environment.execInfo?.run?.executable ?? 'python',
-                ['-m', 'pip', '--version'],
-                undefined,
-                this.log,
+            const versionCmd: PipVersionCommand | UvVersionCommand = await createPipOrUvCommand(
+                { pythonExecutable, log: this.log },
+                environment.environmentPath.fsPath,
+                PipVersionCommand,
+                UvVersionCommand,
             );
-            // "pip X.Y.Z from /path/to/pip (python X.Y)"
-            const match = result.match(/^pip\s+(\d+\.\d+(?:\.\d+)*)/);
-            return match ? (parse(match[1]) ?? undefined) : undefined;
+            return await versionCmd.execute();
         } catch {
             return undefined;
         }
@@ -161,39 +219,42 @@ export class PipPackageManager implements PackageManager, Disposable {
         packageName: string,
     ): Promise<Pep440Version[] | undefined> {
         try {
-            const python = environment.execInfo?.run?.executable;
-            if (!python) {
+            const pythonExecutable = environment.execInfo?.run?.executable;
+            if (!pythonExecutable) {
                 return undefined;
             }
 
-            const baseVersion = parse(environment.version)?.base_version;
+            // Normalize versions like '3.13.1.final.0' (Python's sys.version_info format) to '3.13.1'
+            // before parsing, since pep440 only accepts valid PEP 440 version strings.
+            const versionMatch = (environment.version ?? '').match(/^(\d+(?:\.\d+)*)/);
+            const normalizedVersion = versionMatch?.[1] ?? '';
+            const baseVersion = parse(normalizedVersion)?.base_version;
             if (!baseVersion) {
                 return undefined;
             }
-            // uv - Run pip via `uv tool run pip`
-            const useUv = await shouldUseUv(this.log, environment.environmentPath.fsPath);
-            if (useUv) {
-                const output = await runUV(
-                    ['tool', 'run', 'pip', 'index', 'versions', packageName, '--json', '--python-version', baseVersion],
-                    undefined,
-                    this.log,
-                );
-                return parsePipIndexVersionsJson(output);
-            }
 
-            // pip >= 21.2.0 - use `pip index versions <package> --json` to get available versions in a machine readable format.
-            const pipVersion = await this.getVersion(environment);
-            if (pipVersion && compare(pipVersion.public, '21.2.0') >= 0) {
-                const output = await runPython(
-                    python,
-                    ['-m', 'pip', 'index', 'versions', packageName, '--json', '--python-version', baseVersion],
-                    undefined,
-                    this.log,
+            const availableVersionsCmd: PipAvailableVersionsCommand | UvAvailableVersionsCommand =
+                await createPipOrUvCommand(
+                    { pythonExecutable, log: this.log },
+                    environment.environmentPath.fsPath,
+                    PipAvailableVersionsCommand,
+                    UvAvailableVersionsCommand,
                 );
-                return parsePipIndexVersionsJson(output);
+
+            // For pip < 21.2.0, check version first
+            if (availableVersionsCmd instanceof PipAvailableVersionsCommand) {
+                const pipVersion = await this.getVersion(environment);
+                if (!pipVersion || compare(pipVersion.public, '21.2.0') < 0) {
+                    // pip <= 20.3.4 - version picking is undefined; no reliable machine-readable API exists.
+                    return undefined;
+                }
             }
 
-            // pip <= 20.3.4 - version picking is undefined; no reliable machine-readable API exists.
+            const versions = await availableVersionsCmd.execute({
+                packageName,
+                pythonVersion: baseVersion,
+            });
+            return versions.sort((a, b) => compare(b.public, a.public));
         } catch {
             return undefined;
         }
@@ -205,38 +266,25 @@ export class PipPackageManager implements PackageManager, Disposable {
     }
 
     /**
-     * Returns direct (non-transitive) package names using `pip list --not-required` or `uv pip tree --depth=0`.
+     * Returns direct (non-transitive) package names.
+     *
+     * pip uses `pip list --format=json --not-required`; uv uses `uv pip tree --depth=0`.
      *
-     * Note: These commands return packages with no installed dependents (leaf packages), not packages
-     * the user explicitly installed. pip/uv do not track install intent.
+     * Note: These return top-level packages (no installed dependents / roots of the
+     * dependency tree), not necessarily packages the user explicitly installed. pip/uv
+     * do not track install intent.
      */
     async getDirectPackageNames(environment: PythonEnvironment): Promise<Set<string> | undefined> {
-        const data = await refreshPipDirectPackageNames(environment, this.log);
-        return data ? new Set(data.map(normalizePackageName)) : undefined;
-    }
-}
-
-/**
- * Parses JSON output from `pip index versions <package> --json`.
- * Expected format: { "name": "...", "versions": ["1.2.3", "1.2.2", ...] }
- */
-export function parsePipIndexVersionsJson(output: string): Pep440Version[] | undefined {
-    // Only capture output between braces
-    const match = output.match(/{[\s\S]*}/);
-    if (!match) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(match[0]);
-        if (parsed && Array.isArray(parsed.versions) && parsed.versions.length > 0) {
-            return (parsed.versions as string[])
-                .filter((v) => !!v.trim())
-                .map((v) => parse(v.trim()))
-                .filter((v): v is Pep440Version => v !== null)
-                .sort((a, b) => rcompare(a.public, b.public));
+        const pythonExecutable = environment.execInfo?.run?.executable;
+        if (!pythonExecutable) {
+            return undefined;
         }
-        return undefined;
-    } catch {
-        return undefined;
+        const listDirectNamesCmd: PipListDirectNamesCommand | UvListDirectNamesCommand = await createPipOrUvCommand(
+            { pythonExecutable, log: this.log },
+            environment.environmentPath.fsPath,
+            PipListDirectNamesCommand,
+            UvListDirectNamesCommand,
+        );
+        return listDirectNamesCmd.execute();
     }
 }
diff --git a/src/managers/builtin/pipUtils.ts b/src/managers/builtin/pipUtils.ts
index 055ddb965..54795999d 100644
--- a/src/managers/builtin/pipUtils.ts
+++ b/src/managers/builtin/pipUtils.ts
@@ -13,7 +13,9 @@ import { findFiles } from '../../common/workspace.apis';
 import { selectFromCommonPackagesToInstall, selectFromInstallableToInstall } from '../common/pickers';
 import { Installable } from '../common/types';
 import { mergePackages } from '../common/utils';
-import { normalizePackageName, refreshPipPackages } from './utils';
+import { createPipOrUvCommand } from './commands/factory';
+import { PipListCommand, UvListCommand } from './commands/index';
+import { normalizePackageName } from './utils';
 
 export interface PyprojectToml {
     project?: {
@@ -275,7 +277,17 @@ export async function getWorkspacePackagesToInstall(
     let common = await getCommonPackages();
     let installed: string[] | undefined;
     if (environment) {
-        installed = (await refreshPipPackages(environment, log, { showProgress: true }))?.map((pkg) => pkg.name);
+        const pythonExecutable = environment.execInfo?.run?.executable;
+        if (pythonExecutable) {
+            const listCmd: PipListCommand | UvListCommand = await createPipOrUvCommand(
+                { pythonExecutable, log },
+                environment.environmentPath.fsPath,
+                PipListCommand,
+                UvListCommand,
+            );
+            const data = await listCmd.execute();
+            installed = data?.map((pkg) => pkg.name);
+        }
         common = mergePackages(common, installed ?? []);
     }
     return selectWorkspaceOrCommon(installableResult, common, !!options.showSkipOption, installed ?? []);
@@ -394,10 +406,7 @@ export async function getProjectInstallable(
                                           !path.isAbsolute(relative))
                                   );
                               })
-                              .sort(
-                                  (a, b) =>
-                                      path.dirname(b.fsPath).length - path.dirname(a.fsPath).length,
-                              )
+                              .sort((a, b) => path.dirname(b.fsPath).length - path.dirname(a.fsPath).length)
                         : [];
 
                     if (preferredCandidates.length > 0) {
@@ -502,17 +511,3 @@ export async function shouldProceedAfterPyprojectValidation(
 
     return false;
 }
-
-export function isPipInstallCommand(command: string): boolean {
-    // Regex to match pip install commands, capturing variations like:
-    // pip install package
-    // python -m pip install package
-    // pip3 install package
-    // py -m pip install package
-    // pip install -r requirements.txt
-    // uv pip install package
-    // poetry run pip install package
-    // pipx run pip install package
-    // Any other tool that might wrap pip install
-    return /(?:^|\s)(?:\S+\s+)*(?:pip\d*)\s+(install|uninstall)\b/.test(command);
-}
diff --git a/src/managers/builtin/utils.ts b/src/managers/builtin/utils.ts
index dc44fe759..673209443 100644
--- a/src/managers/builtin/utils.ts
+++ b/src/managers/builtin/utils.ts
@@ -1,19 +1,10 @@
-import { CancellationToken, LogOutputChannel, ProgressLocation, QuickPickItem, Uri, window } from 'vscode';
-import {
-    EnvironmentManager,
-    Package,
-    PackageManagementOptions,
-    PackageManager,
-    PythonEnvironment,
-    PythonEnvironmentApi,
-    PythonEnvironmentInfo,
-} from '../../api';
-import { showErrorMessageWithLogs } from '../../common/errors/utils';
+import { LogOutputChannel, QuickPickItem, Uri, window } from 'vscode';
+import { EnvironmentManager, Package, PythonEnvironment, PythonEnvironmentApi, PythonEnvironmentInfo } from '../../api';
 import { getExtension } from '../../common/extension.apis';
 import { Common, PixiStrings, SysManagerStrings } from '../../common/localize';
 import { traceInfo, traceVerbose } from '../../common/logging';
 import { getGlobalPersistentState } from '../../common/persistentState';
-import { showInformationMessage, withProgress } from '../../common/window.apis';
+import { showInformationMessage } from '../../common/window.apis';
 import { openExtension } from '../../common/workbenchCommands';
 import {
     isNativeEnvInfo,
@@ -22,13 +13,22 @@ import {
     NativePythonFinder,
 } from '../common/nativePythonFinder';
 import { shortenVersionString, sortEnvironments } from '../common/utils';
-import { runPython, runUV, shouldUseUv } from './helpers';
-import { parsePipListJson, parseUvTree, PipPackage } from './pipListUtils';
 
 const PIXI_EXTENSION_ID = 'renan-r-santos.pixi-code';
 const PIXI_RECOMMEND_DONT_ASK_KEY = 'pixi-extension-recommend-dont-ask';
 let pixiRecommendationShown = false;
 
+/**
+ * Parse package specifications (strings) into package objects.
+ * Each string becomes a package object with its packageName; the version is left
+ * unset (the spec string may itself embed a version, e.g. "requests==2.31.0").
+ */
+export function parsePackageSpecs(packageStrings: string[]): { packageName: string; version?: string }[] {
+    return packageStrings.map((pkg) => ({
+        packageName: pkg,
+    }));
+}
+
 function asPackageQuickPickItem(name: string, version?: string): QuickPickItem {
     return {
         label: name,
@@ -183,153 +183,6 @@ export async function refreshPythons(
     return sortEnvironments(collection);
 }
 
-const PIP_LIST_TIMEOUT_MS = 30_000;
-
-async function execPipList(environment: PythonEnvironment, log?: LogOutputChannel, args?: string[]): Promise<string> {
-    // Use environmentPath directly for consistency with UV environment tracking
-    const useUv = await shouldUseUv(log, environment.environmentPath.fsPath);
-    if (useUv) {
-        return await runUV(
-            ['pip', 'list', '--python', environment.execInfo.run.executable, '--format=json', ...(args ?? [])],
-            undefined,
-            log,
-            undefined,
-            PIP_LIST_TIMEOUT_MS,
-        );
-    }
-    try {
-        return await runPython(
-            environment.execInfo.run.executable,
-            ['-m', 'pip', 'list', '--format=json', ...(args ?? [])],
-            undefined,
-            log,
-            undefined,
-            PIP_LIST_TIMEOUT_MS,
-        );
-    } catch (ex) {
-        log?.error('Error running pip list', ex);
-        log?.info(
-            'Package list retrieval attempted using pip, action can be done with uv if installed and setting `alwaysUseUv` is enabled.',
-        );
-        throw ex;
-    }
-}
-
-export async function refreshPipPackages(
-    environment: PythonEnvironment,
-    log?: LogOutputChannel,
-    options?: { showProgress: boolean },
-): Promise<PipPackage[] | undefined> {
-    let data: string;
-    try {
-        if (options?.showProgress) {
-            data = await withProgress(
-                {
-                    location: ProgressLocation.Notification,
-                },
-                async () => {
-                    return await execPipList(environment, log);
-                },
-            );
-        } else {
-            data = await execPipList(environment, log);
-        }
-
-        return parsePipListJson(data, log);
-    } catch (e) {
-        log?.error('Error refreshing packages', e);
-        showErrorMessageWithLogs(SysManagerStrings.packageRefreshError, log);
-        return undefined;
-    }
-}
-
-/**
- * Returns names of packages with no installed dependents (leaf packages).
- *
- * Uses `pip list --not-required` (pip) or `uv pip tree --depth=0` (uv). These report
- * packages that nothing else depends on, which is a proxy for "directly installed" but
- * not equivalent — e.g., `pip install flask werkzeug` will report werkzeug as having
- * dependents (flask) even though the user installed it explicitly.
- */
-export async function refreshPipDirectPackageNames(
-    environment: PythonEnvironment,
-    log?: LogOutputChannel,
-): Promise<string[] | undefined> {
-    const useUv = await shouldUseUv(log, environment.environmentPath.fsPath);
-    if (useUv) {
-        const treeOutput = await runUV(
-            ['pip', 'tree', '--python', environment.execInfo.run.executable, '--depth=0'],
-            undefined,
-            log,
-            undefined,
-            PIP_LIST_TIMEOUT_MS,
-        );
-        return parseUvTree(treeOutput);
-    }
-    const data = await execPipList(environment, log, ['--not-required']);
-    const packages = parsePipListJson(data);
-    return packages.map((pkg) => pkg.name);
-}
-
-export async function managePackages(
-    environment: PythonEnvironment,
-    options: PackageManagementOptions,
-    manager: PackageManager,
-    token?: CancellationToken,
-): Promise<void> {
-    if (environment.version.startsWith('2.')) {
-        throw new Error('Python 2.* is not supported (deprecated)');
-    }
-
-    // Use environmentPath directly for consistency with UV environment tracking
-    const useUv = await shouldUseUv(manager.log, environment.environmentPath.fsPath);
-    const uninstallArgs = ['pip', 'uninstall'];
-    if (options.uninstall && options.uninstall.length > 0) {
-        if (useUv) {
-            await runUV(
-                [...uninstallArgs, '--python', environment.execInfo.run.executable, ...options.uninstall],
-                undefined,
-                manager.log,
-                token,
-            );
-        } else {
-            uninstallArgs.push('--yes');
-            await runPython(
-                environment.execInfo.run.executable,
-                ['-m', ...uninstallArgs, ...options.uninstall],
-                undefined,
-                manager.log,
-                token,
-            );
-        }
-    }
-
-    const installArgs = ['pip', 'install'];
-    if (options.upgrade) {
-        installArgs.push('--upgrade');
-    }
-    if (options.install && options.install.length > 0) {
-        const processedInstallArgs = processEditableInstallArgs(options.install);
-
-        if (useUv) {
-            await runUV(
-                [...installArgs, '--python', environment.execInfo.run.executable, ...processedInstallArgs],
-                undefined,
-                manager.log,
-                token,
-            );
-        } else {
-            await runPython(
-                environment.execInfo.run.executable,
-                ['-m', ...installArgs, ...processedInstallArgs],
-                undefined,
-                manager.log,
-                token,
-            );
-        }
-    }
-}
-
 /**
  * Process pip install arguments to correctly handle editable installs with extras
  * This function will combine consecutive -e arguments that represent the same package with extras
diff --git a/src/managers/builtin/venvUtils.ts b/src/managers/builtin/venvUtils.ts
index c06146999..64e7c2419 100644
--- a/src/managers/builtin/venvUtils.ts
+++ b/src/managers/builtin/venvUtils.ts
@@ -19,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 { isTestExecution } from '../../common/utils/testing';
 import { getVenvPythonPath } from '../../common/utils/virtualEnvironment';
 import {
     showErrorMessage,
@@ -568,14 +569,16 @@ export async function removeVenv(environment: PythonEnvironment, log: LogOutputC
     // Normalize path for UI display - ensure forward slashes on Windows
     const displayPath = normalizePath(envPath);
 
-    const confirm = await showWarningMessage(
-        l10n.t('Are you sure you want to remove {0}?', displayPath),
-        {
-            modal: true,
-        },
-        { title: Common.yes },
-        { title: Common.no, isCloseAffordance: true },
-    );
+    const confirm = isTestExecution()
+        ? { title: Common.yes }
+        : await showWarningMessage(
+              l10n.t('Are you sure you want to remove {0}?', displayPath),
+              {
+                  modal: true,
+              },
+              { title: Common.yes },
+              { title: Common.no, isCloseAffordance: true },
+          );
     if (confirm?.title === Common.yes) {
         const result = await withProgress(
             {
diff --git a/src/managers/conda/condaPackageManager.ts b/src/managers/conda/condaPackageManager.ts
index 4105800ba..df4c305d2 100644
--- a/src/managers/conda/condaPackageManager.ts
+++ b/src/managers/conda/condaPackageManager.ts
@@ -1,5 +1,5 @@
 import type { Pep440Version } from '@renovatebot/pep440';
-import { explain as parse, rcompare } from '@renovatebot/pep440';
+import { compare } from '@renovatebot/pep440';
 import * as path from 'path';
 import {
     CancellationError,
@@ -23,10 +23,18 @@ import {
 } from '../../api';
 import { showErrorMessageWithLogs } from '../../common/errors/utils';
 import { CondaStrings } from '../../common/localize';
-import { traceError } from '../../common/logging';
 import { withProgress } from '../../common/window.apis';
+
+import { parsePackageSpecs } from '../builtin/utils';
 import { updatePackagesAndNotify } from '../common/packageChanges';
-import { getCommonCondaPackagesToInstall, managePackages, runCondaExecutable } from './condaUtils';
+import {
+    CondaAvailableVersionsCommand,
+    CondaInstallCommand,
+    CondaListCommand,
+    CondaUninstallCommand,
+    CondaVersionCommand,
+} from './commands/index';
+import { getCommonCondaPackagesToInstall } from './condaUtils';
 
 export class CondaPackageManager implements PackageManager, Disposable {
     private readonly _onDidChangePackages = new EventEmitter<DidChangePackagesEventArgs>();
@@ -63,40 +71,59 @@ export class CondaPackageManager implements PackageManager, Disposable {
             }
         }
 
-        const manageOptions = {
-            ...options,
-            install: toInstall,
-            uninstall: toUninstall,
-        };
-        await withProgress(
-            {
-                location: ProgressLocation.Notification,
-                title: CondaStrings.condaInstallingPackages,
-                cancellable: true,
-            },
-            async (_progress, token) => {
-                try {
-                    await managePackages(environment, manageOptions, token, this.log);
-                    await updatePackagesAndNotify(
-                        this,
-                        environment,
-                        this.packages.get(environment.envId.id),
-                        (changes) => {
-                            this._onDidChangePackages.fire({ environment, manager: this, changes });
-                        },
-                    );
-                } catch (e) {
-                    if (e instanceof CancellationError) {
-                        throw e;
-                    }
-
-                    this.log.error('Error installing packages', e);
-                    setImmediate(async () => {
-                        await showErrorMessageWithLogs(CondaStrings.condaInstallError, this.log);
-                    });
-                }
-            },
-        );
+        try {
+            // Centralize command options for install/uninstall operations
+            const environmentPath = environment.environmentPath.fsPath;
+
+            // Execute uninstall if needed
+            if (toUninstall.length > 0) {
+                const uninstallCmd = new CondaUninstallCommand({
+                    pythonExecutable: 'conda',
+                    condaEnvironmentPath: environmentPath,
+                    log: this.log,
+                });
+                const packages = parsePackageSpecs(toUninstall);
+                await withProgress(
+                    {
+                        location: ProgressLocation.Notification,
+                        title: CondaStrings.condaInstallingPackages,
+                        cancellable: true,
+                    },
+                    (_progress, token) => uninstallCmd.execute({ packages, cancellationToken: token }),
+                );
+            }
+
+            // Execute install if needed
+            if (toInstall.length > 0) {
+                const installCmd = new CondaInstallCommand({
+                    pythonExecutable: 'conda',
+                    condaEnvironmentPath: environmentPath,
+                    log: this.log,
+                });
+                const packages = parsePackageSpecs(toInstall);
+                await withProgress(
+                    {
+                        location: ProgressLocation.Notification,
+                        title: CondaStrings.condaInstallingPackages,
+                        cancellable: true,
+                    },
+                    (_progress, token) =>
+                        installCmd.execute({ packages, upgrade: options.upgrade, cancellationToken: token }),
+                );
+            }
+
+            await updatePackagesAndNotify(this, environment, this.packages.get(environment.envId.id), (changes) => {
+                this._onDidChangePackages.fire({ environment, manager: this, changes });
+            });
+        } catch (e) {
+            if (e instanceof CancellationError) {
+                throw e;
+            }
+            this.log.error('Error installing packages', e);
+            setImmediate(async () => {
+                await showErrorMessageWithLogs(CondaStrings.condaInstallError, this.log);
+            });
+        }
     }
 
     async refresh(environment: PythonEnvironment): Promise<Package[] | undefined> {
@@ -120,34 +147,13 @@ export class CondaPackageManager implements PackageManager, Disposable {
 
     async getPackages(environment: PythonEnvironment, options?: GetPackagesOptions): Promise<Package[] | undefined> {
         if (options?.skipCache || !this.packages.has(environment.envId.id)) {
-            const args = ['list', '-p', environment.environmentPath.fsPath, '--json'];
-            const data = await runCondaExecutable(args);
-
-            let condaPackages: { name: string; version: string }[];
-            try {
-                condaPackages = JSON.parse(data) as { name: string; version: string }[];
-            } catch (e) {
-                traceError(`Failed to parse conda list JSON output: ${data}`, e);
-                return [];
-            }
-
-            const packages: Package[] = [];
-            for (const condaPkg of condaPackages) {
-                if (condaPkg.name && condaPkg.version) {
-                    packages.push(
-                        this.api.createPackageItem(
-                            {
-                                name: condaPkg.name,
-                                displayName: condaPkg.name,
-                                version: condaPkg.version,
-                                description: condaPkg.version,
-                            },
-                            environment,
-                            this,
-                        ),
-                    );
-                }
-            }
+            const listCmd = new CondaListCommand({
+                pythonExecutable: 'conda',
+                condaEnvironmentPath: environment.environmentPath.fsPath,
+                log: this.log,
+            });
+            const data = await listCmd.execute();
+            const packages = (data ?? []).map((pkg) => this.api.createPackageItem(pkg, environment, this));
             this.packages.set(environment.envId.id, packages);
             return packages;
         }
@@ -161,10 +167,11 @@ export class CondaPackageManager implements PackageManager, Disposable {
 
     async getVersion(_environment: PythonEnvironment): Promise<Pep440Version | undefined> {
         try {
-            const output = await runCondaExecutable(['--version'], this.log);
-            // "conda X.Y.Z"
-            const match = output.match(/conda\s+(\d+\.\d+(?:\.\d+)*)/i);
-            return match ? (parse(match[1]) ?? undefined) : undefined;
+            const versionCmd = new CondaVersionCommand({
+                pythonExecutable: 'conda',
+                log: this.log,
+            });
+            return await versionCmd.execute();
         } catch {
             return undefined;
         }
@@ -175,25 +182,12 @@ export class CondaPackageManager implements PackageManager, Disposable {
         packageName: string,
     ): Promise<Pep440Version[] | undefined> {
         try {
-            const output = await runCondaExecutable(['search', packageName, '--json'], this.log);
-            const parsed = JSON.parse(output);
-            if (parsed && typeof parsed === 'object' && Array.isArray(parsed[packageName])) {
-                const uniqueVersions = new Map<string, Pep440Version>();
-                parsed[packageName]
-                    .filter((entry: { version?: string }) => !!entry.version?.trim())
-                    .map((entry: { version?: string }) => parse(entry.version!))
-                    .filter((v: Pep440Version | null): v is Pep440Version => v !== null)
-                    .forEach((version: Pep440Version) => {
-                        if (!uniqueVersions.has(version.public)) {
-                            uniqueVersions.set(version.public, version);
-                        }
-                    });
-
-                return Array.from(uniqueVersions.values()).sort((a: Pep440Version, b: Pep440Version) =>
-                    rcompare(a.public, b.public),
-                );
-            }
-            return undefined;
+            const availableVersionsCmd = new CondaAvailableVersionsCommand({
+                pythonExecutable: 'conda',
+                log: this.log,
+            });
+            const versions = await availableVersionsCmd.execute({ packageName, pythonVersion: '' });
+            return versions.sort((a, b) => compare(b.public, a.public));
         } catch {
             return undefined;
         }
diff --git a/src/managers/conda/condaUtils.ts b/src/managers/conda/condaUtils.ts
index 06d3ec54f..eee067ce3 100644
--- a/src/managers/conda/condaUtils.ts
+++ b/src/managers/conda/condaUtils.ts
@@ -1250,29 +1250,6 @@ export async function deleteCondaEnvironment(environment: PythonEnvironment, log
     );
 }
 
-export async function managePackages(
-    environment: PythonEnvironment,
-    options: PackageManagementOptions,
-    token: CancellationToken,
-    log: LogOutputChannel,
-): Promise<void> {
-    if (options.uninstall && options.uninstall.length > 0) {
-        await runCondaExecutable(
-            ['remove', '--prefix', environment.environmentPath.fsPath, '--yes', ...options.uninstall],
-            log,
-            token,
-        );
-    }
-    if (options.install && options.install.length > 0) {
-        const args = ['install', '--prefix', environment.environmentPath.fsPath, '--yes'];
-        if (options.upgrade) {
-            args.push('--update-all');
-        }
-        args.push(...options.install);
-        await runCondaExecutable(args, log, token);
-    }
-}
-
 async function getCommonPackages(): Promise<Installable[]> {
     try {
         const pipData = path.join(EXTENSION_ROOT_DIR, 'files', 'conda_packages.json');
diff --git a/src/managers/poetry/poetryPackageManager.ts b/src/managers/poetry/poetryPackageManager.ts
index 54845a20b..7d37eb539 100644
--- a/src/managers/poetry/poetryPackageManager.ts
+++ b/src/managers/poetry/poetryPackageManager.ts
@@ -1,10 +1,8 @@
 import type { Pep440Version } from '@renovatebot/pep440';
-import { explain as parse } from '@renovatebot/pep440';
 import * as fsapi from 'fs-extra';
 import * as path from 'path';
 import {
     CancellationError,
-    CancellationToken,
     Event,
     EventEmitter,
     l10n,
@@ -24,12 +22,18 @@ import {
     PythonEnvironment,
     PythonEnvironmentApi,
 } from '../../api';
-import { spawnProcess } from '../../common/childProcess.apis';
 import { showErrorMessage, showInputBox, withProgress } from '../../common/window.apis';
-import { normalizePackageName } from '../builtin/utils';
+import { parsePackageSpecs } from '../builtin/utils';
 import { updatePackagesAndNotify } from '../common/packageChanges';
+import {
+    PoetryAddCommand,
+    PoetryRemoveCommand,
+    PoetryShowCommand,
+    PoetryShowTopLevelCommand,
+    PoetryVersionCommand,
+} from './commands/index';
 import { PoetryManager } from './poetryManager';
-import { getPoetry, getPoetryVersion } from './poetryUtils';
+import { getPoetry } from './poetryUtils';
 
 export class PoetryPackageManager implements PackageManager, Disposable {
     private readonly _onDidChangePackages = new EventEmitter<DidChangePackagesEventArgs>();
@@ -77,38 +81,25 @@ export class PoetryPackageManager implements PackageManager, Disposable {
             }
         }
 
-        await withProgress(
-            {
-                location: ProgressLocation.Notification,
-                title: 'Managing packages with Poetry',
-                cancellable: true,
-            },
-            async (_progress, token) => {
-                try {
-                    await this.runPoetryManage({ install: toInstall, uninstall: toUninstall }, token);
-                    await updatePackagesAndNotify(
-                        this,
-                        environment,
-                        this.packages.get(environment.envId.id),
-                        (changes) => {
-                            this._onDidChangePackages.fire({ environment, manager: this, changes });
-                        },
-                    );
-                } catch (e) {
-                    if (e instanceof CancellationError) {
-                        throw e;
-                    }
-                    this.log.error('Error managing packages with Poetry', e);
-                    setImmediate(async () => {
-                        const result = await showErrorMessage('Error managing packages with Poetry', 'View Output');
-                        if (result === 'View Output') {
-                            this.log.show();
-                        }
-                    });
-                    throw e;
+        try {
+            await this.runPoetryManage({ install: toInstall, uninstall: toUninstall });
+            await updatePackagesAndNotify(this, environment, this.packages.get(environment.envId.id), (changes) => {
+                this._onDidChangePackages.fire({ environment, manager: this, changes });
+            });
+        } catch (e) {
+            if (e instanceof CancellationError) {
+                // Cancellation is not an error; rethrow without surfacing an error message.
+                throw e;
+            }
+            this.log.error('Error managing packages with Poetry', e);
+            setImmediate(async () => {
+                const result = await showErrorMessage('Error managing packages with Poetry', 'View Output');
+                if (result === 'View Output') {
+                    this.log.show();
                 }
-            },
-        );
+            });
+            throw e;
+        }
     }
 
     async refresh(environment: PythonEnvironment): Promise<Package[] | undefined> {
@@ -156,8 +147,11 @@ export class PoetryPackageManager implements PackageManager, Disposable {
         if (!poetry) {
             return undefined;
         }
-        const versionStr = await getPoetryVersion(poetry);
-        return versionStr ? (parse(versionStr) ?? undefined) : undefined;
+        const versionCmd = new PoetryVersionCommand({
+            pythonExecutable: poetry,
+            log: this.log,
+        });
+        return await versionCmd.execute();
     }
 
     async getPackageAvailableVersions(
@@ -180,10 +174,7 @@ export class PoetryPackageManager implements PackageManager, Disposable {
         this.packages.clear();
     }
 
-    private async runPoetryManage(
-        options: { install?: string[]; uninstall?: string[] },
-        token?: CancellationToken,
-    ): Promise<void> {
+    private async runPoetryManage(options: { install?: string[]; uninstall?: string[] }): Promise<void> {
         const poetry = await getPoetry();
         if (!poetry) {
             throw new Error(
@@ -192,31 +183,30 @@ export class PoetryPackageManager implements PackageManager, Disposable {
                 ),
             );
         }
-
         // Handle uninstalls first
         if (options.uninstall && options.uninstall.length > 0) {
-            try {
-                const args = ['remove', ...options.uninstall];
-                this.log.info(`Running: poetry ${args.join(' ')}`);
-                const result = await runPoetry(args, undefined, this.log, token);
-                this.log.info(result);
-            } catch (err) {
-                this.log.error(`Error removing packages with Poetry: ${err}`);
-                throw err;
-            }
+            const removeCmd = new PoetryRemoveCommand({
+                pythonExecutable: poetry,
+                log: this.log,
+            });
+            const packages = parsePackageSpecs(options.uninstall);
+            await withProgress(
+                { location: ProgressLocation.Notification, title: 'Managing packages with Poetry', cancellable: true },
+                (_progress, token) => removeCmd.execute({ packages, cancellationToken: token }),
+            );
         }
 
         // Handle installs
         if (options.install && options.install.length > 0) {
-            try {
-                const args = ['add', ...options.install];
-                this.log.info(`Running: poetry ${args.join(' ')}`);
-                const result = await runPoetry(args, undefined, this.log, token);
-                this.log.info(result);
-            } catch (err) {
-                this.log.error(`Error adding packages with Poetry: ${err}`);
-                throw err;
-            }
+            const addCmd = new PoetryAddCommand({
+                pythonExecutable: poetry,
+                log: this.log,
+            });
+            const packages = parsePackageSpecs(options.install);
+            await withProgress(
+                { location: ProgressLocation.Notification, title: 'Managing packages with Poetry', cancellable: true },
+                (_progress, token) => addCmd.execute({ packages, cancellationToken: token }),
+            );
         }
     }
 
@@ -230,126 +220,62 @@ export class PoetryPackageManager implements PackageManager, Disposable {
             );
         }
 
-        let cwd = process.cwd();
-        const projects = this.api.getPythonProjects();
-        if (projects.length === 1) {
-            const stat = await fsapi.stat(projects[0].uri.fsPath);
-            if (stat.isDirectory()) {
-                cwd = projects[0].uri.fsPath;
-            } else {
-                cwd = path.dirname(projects[0].uri.fsPath);
-            }
-        } else if (projects.length > 1) {
-            const dirs = new Set<string>();
-            await Promise.all(
-                projects.map(async (project) => {
-                    const e = await this.api.getEnvironment(project.uri);
-                    if (e?.envId.id === environment.envId.id) {
-                        const stat = await fsapi.stat(projects[0].uri.fsPath);
-                        const dir = stat.isDirectory() ? projects[0].uri.fsPath : path.dirname(projects[0].uri.fsPath);
-                        if (dirs.has(dir)) {
-                            dirs.add(dir);
-                        }
-                    }
-                }),
-            );
-            if (dirs.size > 0) {
-                // ensure we have the deepest directory node picked
-                cwd = Array.from(dirs.values()).sort((a, b) => (a.length - b.length) * -1)[0];
-            }
-        }
-
-        const poetryPackages: { name: string; version: string; displayName: string; description: string }[] = [];
-
-        try {
-            this.log.info(`Running: ${await getPoetry()} show --no-ansi`);
-            const result = await runPoetry(['show', '--no-ansi'], cwd, this.log);
-
-            // Parse poetry show output
-            // Format: name         version    description
-            const lines = result.split('\n');
-            for (const line of lines) {
-                // Updated regex to properly handle lines with the format:
-                // "package (!) version description"
-                const match = line.match(/^(\S+)(?:\s+\([!]\))?\s+(\S+)\s+(.*)/);
-                if (match) {
-                    const [, name, version, description] = match;
-                    poetryPackages.push({
-                        name,
-                        version,
-                        displayName: name,
-                        description: `${version} - ${description?.trim() || ''}`,
-                    });
-                }
-            }
-        } catch (err) {
-            this.log.error(`Error refreshing packages with Poetry: ${err}`);
-            // Return empty array instead of throwing to avoid breaking the UI
-            return [];
-        }
-
-        // Convert to Package objects using the API
-        return poetryPackages.map((pkg) => this.api.createPackageItem(pkg, environment, this));
+        const cwd = await this.getPoetryCwd(environment);
+        const showCmd = new PoetryShowCommand({
+            pythonExecutable: poetry,
+            cwd,
+            log: this.log,
+        });
+        const data = await showCmd.execute();
+        return (data ?? []).map((pkg) => this.api.createPackageItem(pkg, environment, this));
     }
 
     async getDirectPackageNames(_environment: PythonEnvironment): Promise<Set<string> | undefined> {
         try {
-            const topLevelResult = await runPoetry(['show', '--no-ansi', '--top-level'], undefined, this.log);
-            const names = topLevelResult
-                .split('\n')
-                .map((line) => line.trim())
-                .map((line) => line.match(/^([a-zA-Z0-9._-]+)/)?.[1] ?? '')
-                .filter((name) => !!name)
-                .map(normalizePackageName);
-            return new Set(names);
+            const poetry = await getPoetry();
+            if (!poetry) {
+                return undefined;
+            }
+            const showTopLevelCmd = new PoetryShowTopLevelCommand({
+                pythonExecutable: poetry,
+                log: this.log,
+            });
+            return await showTopLevelCmd.execute();
         } catch (err) {
             this.log.error(`Error fetching direct package names with Poetry: ${err}`);
             return undefined;
         }
     }
-}
-
-export async function runPoetry(
-    args: string[],
-    cwd?: string,
-    log?: LogOutputChannel,
-    token?: CancellationToken,
-): Promise<string> {
-    const poetry = await getPoetry();
-    if (!poetry) {
-        throw new Error('Poetry executable not found');
-    }
 
-    log?.info(`Running: ${poetry} ${args.join(' ')}`);
+    private async getPoetryCwd(environment: PythonEnvironment): Promise<string | undefined> {
+        const projects = this.api.getPythonProjects();
+        if (projects.length === 0) {
+            return undefined;
+        }
 
-    return new Promise<string>((resolve, reject) => {
-        const proc = spawnProcess(poetry, args, { cwd });
-        token?.onCancellationRequested(() => {
-            proc.kill();
-            reject(new CancellationError());
-        });
-        let builder = '';
-        proc.stdout?.on('data', (data) => {
-            const s = data.toString('utf-8');
-            builder += s;
-            log?.append(`poetry: ${s}`);
-        });
-        proc.stderr?.on('data', (data) => {
-            const s = data.toString('utf-8');
-            builder += s;
-            log?.append(`poetry: ${s}`);
-        });
-        proc.on('close', () => {
-            resolve(builder);
-        });
-        proc.on('error', (error) => {
-            log?.error(`Error executing poetry command: ${error}`);
-            reject(error);
-        });
-        proc.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Failed to run poetry ${args.join(' ')}`));
+        const toDirectory = async (fsPath: string): Promise<string> => {
+            try {
+                const stat = await fsapi.stat(fsPath);
+                return stat.isDirectory() ? fsPath : path.dirname(fsPath);
+            } catch {
+                return path.dirname(fsPath);
             }
-        });
-    });
+        };
+
+        if (projects.length === 1) {
+            return toDirectory(projects[0].uri.fsPath);
+        }
+
+        const matchingDirectories = new Set<string>();
+        await Promise.all(
+            projects.map(async (project) => {
+                const projectEnvironment = await this.api.getEnvironment(project.uri);
+                if (projectEnvironment?.envId.id === environment.envId.id) {
+                    matchingDirectories.add(await toDirectory(project.uri.fsPath));
+                }
+            }),
+        );
+
+        return Array.from(matchingDirectories).sort((a, b) => b.length - a.length)[0];
+    }
 }
diff --git a/src/test/integration/packageManagerRoundtrip.integration.test.ts b/src/test/integration/packageManagerRoundtrip.integration.test.ts
new file mode 100644
index 000000000..b16a333c6
--- /dev/null
+++ b/src/test/integration/packageManagerRoundtrip.integration.test.ts
@@ -0,0 +1,252 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+/**
+ * Integration Test: Package Manager Roundtrip
+ *
+ * Verifies package lifecycle operations through the public API using disposable
+ * environments. Each fixture owns both sides of the test:
+ *
+ *   1. Create an environment with the configured environment manager.
+ *   2. Exercise the environment manager's preferred package manager.
+ *   3. Remove the environment, even when the package roundtrip fails.
+ *
+ * Poetry and Pipenv are intentionally excluded until their environment lifecycle
+ * setup can participate in the same disposable fixture contract.
+ */
+
+import * as assert from 'assert';
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import * as vscode from 'vscode';
+import { Package, PythonEnvironment, PythonEnvironmentApi, PythonProject } from '../../api';
+import {
+    CONDA_MANAGER_ID,
+    DEFAULT_PACKAGE_MANAGER_ID,
+    SYSTEM_MANAGER_ID,
+    VENV_MANAGER_ID,
+} from '../../common/constants';
+import { normalizePackageName } from '../../managers/builtin/utils';
+import { ENVS_EXTENSION_ID } from '../constants';
+import { waitForCondition } from '../testUtils';
+
+interface PackageManagerFixture {
+    name: string;
+    environmentManagerId: string;
+    packageManagerId: string;
+    alwaysUseUv?: boolean;
+    isAvailable(environments: PythonEnvironment[]): boolean;
+}
+
+const TEST_PACKAGE = 'flask';
+
+const PACKAGE_MANAGER_FIXTURES: PackageManagerFixture[] = [
+    {
+        name: 'Venv with Pip',
+        environmentManagerId: VENV_MANAGER_ID,
+        packageManagerId: DEFAULT_PACKAGE_MANAGER_ID,
+        alwaysUseUv: false,
+        isAvailable: (environments) =>
+            environments.some(
+                (environment) =>
+                    environment.envId.managerId === SYSTEM_MANAGER_ID && environment.version.startsWith('3.'),
+            ),
+    },
+    {
+        name: 'Conda with Conda',
+        environmentManagerId: CONDA_MANAGER_ID,
+        packageManagerId: CONDA_MANAGER_ID,
+        isAvailable: (environments) =>
+            environments.some((environment) => environment.envId.managerId === CONDA_MANAGER_ID),
+    },
+];
+
+type AvailableVersionsCapable = {
+    getPackageAvailableVersions?: (
+        environment: PythonEnvironment,
+        packageName: string,
+    ) => Promise<unknown[] | undefined>;
+};
+
+function hasPackage(packages: Package[] | undefined, name: string): boolean {
+    const target = normalizePackageName(name);
+    return (packages ?? []).some((pkg) => normalizePackageName(pkg.name) === target);
+}
+
+async function withManagerSettings<T>(
+    fixture: PackageManagerFixture,
+    scope: vscode.Uri,
+    callback: () => Promise<T>,
+): Promise<T> {
+    const config = vscode.workspace.getConfiguration('python-envs', scope);
+    const originalEnvironmentManager = config.inspect<string>('defaultEnvManager')?.workspaceValue;
+    const originalPackageManager = config.inspect<string>('defaultPackageManager')?.workspaceValue;
+    const originalAlwaysUseUv = config.inspect<boolean>('alwaysUseUv')?.globalValue;
+
+    try {
+        await config.update(
+            'defaultEnvManager',
+            fixture.environmentManagerId,
+            vscode.ConfigurationTarget.Workspace,
+        );
+        await config.update(
+            'defaultPackageManager',
+            fixture.packageManagerId,
+            vscode.ConfigurationTarget.Workspace,
+        );
+        if (fixture.alwaysUseUv !== undefined) {
+            await config.update('alwaysUseUv', fixture.alwaysUseUv, vscode.ConfigurationTarget.Global);
+        }
+        return await callback();
+    } finally {
+        const restorations = [
+            config.update(
+                'defaultEnvManager',
+                originalEnvironmentManager,
+                vscode.ConfigurationTarget.Workspace,
+            ),
+            config.update(
+                'defaultPackageManager',
+                originalPackageManager,
+                vscode.ConfigurationTarget.Workspace,
+            ),
+        ];
+        if (fixture.alwaysUseUv !== undefined) {
+            restorations.push(
+                config.update('alwaysUseUv', originalAlwaysUseUv, vscode.ConfigurationTarget.Global),
+            );
+        }
+        await Promise.all(restorations);
+    }
+}
+
+async function runRoundtrip(
+    api: PythonEnvironmentApi,
+    environment: PythonEnvironment,
+    packageManagerId: string,
+): Promise<void> {
+    const baseline = await api.getPackages(environment, { skipCache: true });
+    assert.notStrictEqual(baseline, undefined, `[${packageManagerId}] Package manager should be available`);
+    assert.ok(
+        !hasPackage(baseline, TEST_PACKAGE),
+        `[${packageManagerId}] ${TEST_PACKAGE} should be absent from the new environment`,
+    );
+
+    await api.managePackages(environment, { install: [TEST_PACKAGE] });
+
+    const afterInstall =
+        (await api.refreshPackages(environment)) ?? (await api.getPackages(environment, { skipCache: true }));
+    const installedPackage = (afterInstall ?? []).find(
+        (pkg) => normalizePackageName(pkg.name) === normalizePackageName(TEST_PACKAGE),
+    );
+    assert.ok(installedPackage, `[${packageManagerId}] ${TEST_PACKAGE} should be installed`);
+    assert.strictEqual(
+        installedPackage.pkgId.managerId,
+        packageManagerId,
+        `[${packageManagerId}] ${TEST_PACKAGE} should use the expected package manager`,
+    );
+    assert.notStrictEqual(
+        installedPackage.isTransitive,
+        true,
+        `[${packageManagerId}] ${TEST_PACKAGE} should be reported as a direct package`,
+    );
+
+    const classifiesTransitivity = (afterInstall ?? []).some((pkg) => pkg.isTransitive !== undefined);
+    if (classifiesTransitivity) {
+        assert.ok(
+            (afterInstall ?? []).some((pkg) => pkg.isTransitive === true),
+            `[${packageManagerId}] A ${TEST_PACKAGE} dependency should be reported as transitive`,
+        );
+    }
+
+    const versionsApi = api as AvailableVersionsCapable;
+    if (typeof versionsApi.getPackageAvailableVersions === 'function') {
+        const versions = await versionsApi.getPackageAvailableVersions(environment, TEST_PACKAGE);
+        if (versions !== undefined) {
+            assert.ok(
+                Array.isArray(versions) && versions.length > 0,
+                `[${packageManagerId}] ${TEST_PACKAGE} should report available versions`,
+            );
+        }
+    }
+
+    await api.managePackages(environment, { uninstall: [TEST_PACKAGE] });
+    await api.refreshPackages(environment);
+    const afterUninstall = await api.getPackages(environment, { skipCache: true });
+    assert.ok(!hasPackage(afterUninstall, TEST_PACKAGE), `[${packageManagerId}] ${TEST_PACKAGE} should be uninstalled`);
+}
+
+suite('Integration: Package Manager Roundtrip', function () {
+    this.timeout(600_000); // Environment creation and Conda package solving can both be slow.
+
+    let api: PythonEnvironmentApi;
+    let originalTestExecution: string | undefined;
+
+    suiteSetup(async function () {
+        this.timeout(30_000);
+        originalTestExecution = process.env.VSC_PYTHON_CI_TEST;
+        process.env.VSC_PYTHON_CI_TEST = '1';
+
+        const extension = vscode.extensions.getExtension(ENVS_EXTENSION_ID);
+        assert.ok(extension, `Extension ${ENVS_EXTENSION_ID} not found`);
+
+        if (!extension.isActive) {
+            await extension.activate();
+            await waitForCondition(() => extension.isActive, 20_000, 'Extension did not activate');
+        }
+
+        api = extension.exports as PythonEnvironmentApi;
+        assert.ok(api, 'API not available');
+    });
+
+    suiteTeardown(() => {
+        if (originalTestExecution === undefined) {
+            delete process.env.VSC_PYTHON_CI_TEST;
+        } else {
+            process.env.VSC_PYTHON_CI_TEST = originalTestExecution;
+        }
+    });
+
+    for (const fixture of PACKAGE_MANAGER_FIXTURES) {
+        test(`${fixture.name}: disposable environment package roundtrip`, async function () {
+            const globalEnvironments = await api.getEnvironments('global');
+            if (!fixture.isAvailable(globalEnvironments)) {
+                this.skip();
+                return;
+            }
+
+            const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'python-envs-package-roundtrip-'));
+            const project: PythonProject = {
+                name: `Package roundtrip: ${fixture.name}`,
+                uri: vscode.Uri.file(projectRoot),
+            };
+            let environment: PythonEnvironment | undefined;
+
+            api.addPythonProject(project);
+
+            try {
+                await withManagerSettings(fixture, project.uri, async () => {
+                    environment = await api.createEnvironment(project.uri, { quickCreate: true });
+                    assert.ok(environment, `[${fixture.name}] Environment creation should succeed`);
+                    assert.strictEqual(
+                        environment.envId.managerId,
+                        fixture.environmentManagerId,
+                        `[${fixture.name}] Environment should use the expected manager`,
+                    );
+
+                    await runRoundtrip(api, environment, fixture.packageManagerId);
+                });
+            } finally {
+                try {
+                    if (environment) {
+                        await api.removeEnvironment(environment);
+                    }
+                } finally {
+                    api.removePythonProject(project);
+                    await fs.remove(projectRoot);
+                }
+            }
+        });
+    }
+});
diff --git a/src/test/managers/builtin/commands.unit.test.ts b/src/test/managers/builtin/commands.unit.test.ts
new file mode 100644
index 000000000..e1c5e97d0
--- /dev/null
+++ b/src/test/managers/builtin/commands.unit.test.ts
@@ -0,0 +1,188 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { explain } from '@renovatebot/pep440';
+import assert from 'assert';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import { LogOutputChannel } from 'vscode';
+import * as workspaceApis from '../../../common/workspace.apis';
+import {
+    PipAvailableVersionsCommand,
+    UvAvailableVersionsCommand,
+} from '../../../managers/builtin/commands/availableVersions';
+import { PipListCommand, UvListCommand } from '../../../managers/builtin/commands/list';
+import { PipListDirectNamesCommand, UvListDirectNamesCommand } from '../../../managers/builtin/commands/listDirectNames';
+import * as helpers from '../../../managers/builtin/helpers';
+import { EXTENSION_TEST_ROOT } from '../../constants';
+import { createMockLogOutputChannel } from '../../mocks/helper';
+
+suite('Pip and UV command parsing', () => {
+    const testDataRoot = path.join(EXTENSION_TEST_ROOT, 'managers', 'builtin');
+    let log: LogOutputChannel;
+    let runPythonStub: sinon.SinonStub;
+    let runUvStub: sinon.SinonStub;
+
+    setup(() => {
+        log = createMockLogOutputChannel();
+        sinon.stub(workspaceApis, 'getConfiguration').returns({
+            get: () => undefined,
+        } as unknown as ReturnType<typeof workspaceApis.getConfiguration>);
+        runPythonStub = sinon.stub(helpers, 'runPython').resolves('');
+        runUvStub = sinon.stub(helpers, 'runUV').resolves('');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    for (const testName of ['piplist1', 'piplist2', 'piplist3']) {
+        test(`PipListCommand parses ${testName}`, async () => {
+            const expected = JSON.parse(
+                await fs.readFile(path.join(testDataRoot, `${testName}.expected.json`), 'utf8'),
+            ) as { packages: { name: string; version: string }[] };
+            runPythonStub.resolves(JSON.stringify(expected.packages));
+            const command = new PipListCommand({ pythonExecutable: 'python', log });
+
+            const packages = await command.execute();
+
+            assert.deepStrictEqual(
+                packages,
+                expected.packages.map(({ name, version }) => ({
+                    name,
+                    version,
+                    displayName: name,
+                    description: version,
+                })),
+            );
+        });
+    }
+
+    test('PipListCommand returns no packages and logs malformed JSON', async () => {
+        runPythonStub.resolves('not json');
+        const command = new PipListCommand({ pythonExecutable: 'python', log });
+
+        assert.deepStrictEqual(await command.execute(), []);
+        assert.strictEqual((log.error as sinon.SinonStub).callCount, 1);
+    });
+
+    test('PipListCommand rejects non-array output and incomplete entries', async () => {
+        const command = new PipListCommand({ pythonExecutable: 'python', log });
+        runPythonStub.resolves('{"name":"pip","version":"24.0"}');
+        assert.deepStrictEqual(await command.execute(), []);
+
+        runPythonStub.resolves(
+            JSON.stringify([{ name: 'pip', version: '24.0' }, { name: 'setuptools' }, { version: '1.0' }]),
+        );
+        assert.deepStrictEqual(await command.execute(), [
+            {
+                name: 'pip',
+                version: '24.0',
+                displayName: 'pip',
+                description: '24.0',
+            },
+        ]);
+    });
+
+    test('UvListCommand handles valid and malformed JSON', async () => {
+        const command = new UvListCommand({ pythonExecutable: 'python', log });
+        runUvStub.resolves(JSON.stringify([{ name: 'pip', version: '24.0' }]));
+        assert.deepStrictEqual(await command.execute(), [
+            {
+                name: 'pip',
+                version: '24.0',
+                displayName: 'pip',
+                description: '24.0',
+            },
+        ]);
+
+        runUvStub.resolves('not json');
+        assert.deepStrictEqual(await command.execute(), []);
+    });
+
+    test('PipListDirectNamesCommand normalizes names and ignores invalid entries', async () => {
+        runPythonStub.resolves(JSON.stringify([{ name: 'My_Package' }, { version: '1.0' }, { name: '' }]));
+        const command = new PipListDirectNamesCommand({ pythonExecutable: 'python', log });
+
+        assert.deepStrictEqual(await command.execute(), new Set(['my-package']));
+    });
+
+    test('UvListDirectNamesCommand parses top-level packages only', async () => {
+        runUvStub.resolves(
+            [
+                'My_Package v1.0.0',
+                '├── dependency v2.0.0',
+                '│   └── nested-dependency v3.0.0',
+                'another.package v4.0.0',
+                '',
+            ].join('\n'),
+        );
+        const command = new UvListDirectNamesCommand({ pythonExecutable: 'python', log });
+
+        assert.deepStrictEqual(await command.execute(), new Set(['my-package', 'another-package']));
+    });
+
+    test('UvListDirectNamesCommand handles empty and indented-only output', async () => {
+        const command = new UvListDirectNamesCommand({ pythonExecutable: 'python', log });
+        runUvStub.resolves('');
+        assert.deepStrictEqual(await command.execute(), new Set());
+
+        runUvStub.resolves('  indented v1.0.0\n└── dependency v2.0.0');
+        assert.deepStrictEqual(await command.execute(), new Set());
+    });
+
+    test('PipAvailableVersionsCommand parses, deduplicates, and filters versions', async () => {
+        runPythonStub.resolves(
+            `warning before JSON\n${JSON.stringify({
+                versions: ['2.0.0', '2.0.0', '2.1.0rc1', ' invalid ', '1.0.0'],
+            })}\nwarning after JSON`,
+        );
+        const command = new PipAvailableVersionsCommand({ pythonExecutable: 'python', log });
+
+        const versions = await command.execute({
+            packageName: 'package',
+            pythonVersion: '3.13',
+            includePrerelease: false,
+        });
+
+        assert.deepStrictEqual(
+            versions.map((version) => version.public),
+            ['2.0.0', '1.0.0'],
+        );
+    });
+
+    test('PipAvailableVersionsCommand handles malformed output', async () => {
+        const command = new PipAvailableVersionsCommand({ pythonExecutable: 'python', log });
+        runPythonStub.resolves('no JSON here');
+        assert.deepStrictEqual(
+            await command.execute({ packageName: 'package', pythonVersion: '3.13' }),
+            [],
+        );
+
+        runPythonStub.resolves('{not valid JSON}');
+        assert.deepStrictEqual(
+            await command.execute({ packageName: 'package', pythonVersion: '3.13' }),
+            [],
+        );
+
+        runPythonStub.resolves(JSON.stringify({ versions: '1.0.0' }));
+        assert.deepStrictEqual(
+            await command.execute({ packageName: 'package', pythonVersion: '3.13' }),
+            [],
+        );
+    });
+
+    test('UvAvailableVersionsCommand returns parsed prerelease versions when requested', async () => {
+        runUvStub.resolves(JSON.stringify({ versions: ['1.0.0', '2.0.0rc1'] }));
+        const command = new UvAvailableVersionsCommand({ pythonExecutable: 'python', log });
+
+        const versions = await command.execute({
+            packageName: 'package',
+            pythonVersion: '3.13',
+            includePrerelease: true,
+        });
+
+        assert.deepStrictEqual(versions, [explain('1.0.0'), explain('2.0.0rc1')]);
+    });
+});
diff --git a/src/test/managers/builtin/pipListUtils.unit.test.ts b/src/test/managers/builtin/pipListUtils.unit.test.ts
deleted file mode 100644
index 0bc978e9f..000000000
--- a/src/test/managers/builtin/pipListUtils.unit.test.ts
+++ /dev/null
@@ -1,123 +0,0 @@
-import assert from 'assert';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import * as sinon from 'sinon';
-import { LogOutputChannel } from 'vscode';
-import { parsePipListJson, parseUvTree } from '../../../managers/builtin/pipListUtils';
-import { EXTENSION_TEST_ROOT } from '../../constants';
-
-const TEST_DATA_ROOT = path.join(EXTENSION_TEST_ROOT, 'managers', 'builtin');
-
-suite('Pip List JSON Parser tests', () => {
-    let log: LogOutputChannel;
-
-    setup(() => {
-        log = {
-            error: sinon.stub(),
-            warn: sinon.stub(),
-            info: sinon.stub(),
-        } as unknown as LogOutputChannel;
-    });
-
-    teardown(() => {
-        sinon.restore();
-    });
-
-    const testNames = ['piplist1', 'piplist2', 'piplist3'];
-
-    testNames.forEach((testName) => {
-        test(`Test parsing pip list JSON output ${testName}`, async () => {
-            const expected = JSON.parse(
-                await fs.readFile(path.join(TEST_DATA_ROOT, `${testName}.expected.json`), 'utf8'),
-            );
-            const pipListOutput = JSON.stringify(expected.packages);
-
-            const actualPackages = parsePipListJson(pipListOutput, log);
-
-            assert.equal(actualPackages.length, expected.packages.length, 'Unexpected number of packages');
-            actualPackages.forEach((actualPackage) => {
-                const expectedPackage = expected.packages.find(
-                    (item: { name: string }) => item.name === actualPackage.name,
-                );
-                assert.ok(expectedPackage, `Package ${actualPackage.name} not found in expected packages`);
-                assert.equal(actualPackage.version, expectedPackage.version, 'Version mismatch');
-            });
-
-            expected.packages.forEach((expectedPackage: { name: string; version: string }) => {
-                const actualPackage = actualPackages.find((item) => item.name === expectedPackage.name);
-                assert.ok(actualPackage, `Package ${expectedPackage.name} not found in actual packages`);
-                assert.equal(actualPackage.version, expectedPackage.version, 'Version mismatch');
-            });
-        });
-    });
-
-    test('Returns an empty array for invalid JSON input', () => {
-        assert.deepStrictEqual(parsePipListJson('not json', log), []);
-    });
-
-    test('Logs error when JSON parsing fails', () => {
-        parsePipListJson('not valid json', log);
-        assert.ok((log.error as sinon.SinonStub).calledOnce, 'Expected error to be logged');
-    });
-
-    test('Returns empty array without logging when no log is provided', () => {
-        const result = parsePipListJson('not valid json');
-        assert.deepStrictEqual(result, []);
-    });
-
-    test('Skips items without a name or version', () => {
-        const actualPackages = parsePipListJson(
-            JSON.stringify([{ name: 'pip', version: '24.0' }, { name: 'setuptools' }, { version: '1.0.0' }]),
-            log,
-        );
-
-        assert.deepStrictEqual(actualPackages, [
-            {
-                name: 'pip',
-                version: '24.0',
-                displayName: 'pip',
-                description: '24.0',
-            },
-        ]);
-    });
-
-    test('Returns empty array for non-array JSON', () => {
-        const result = parsePipListJson('{"name": "pip"}', log);
-        assert.deepStrictEqual(result, []);
-    });
-
-    test('Returns empty array for empty array JSON', () => {
-        const result = parsePipListJson('[]', log);
-        assert.deepStrictEqual(result, []);
-    });
-});
-
-suite('parseUvTree tests', () => {
-    test('Parses uv pip tree output with depth 0', () => {
-        const input = 'requests v2.31.0\nflask v3.0.0\n';
-        const result = parseUvTree(input);
-        assert.deepStrictEqual(result, ['requests', 'flask']);
-    });
-
-    test('Handles empty output', () => {
-        assert.deepStrictEqual(parseUvTree(''), []);
-    });
-
-    test('Filters blank lines', () => {
-        const input = 'requests v2.31.0\n\n\nflask v3.0.0\n';
-        const result = parseUvTree(input);
-        assert.deepStrictEqual(result, ['requests', 'flask']);
-    });
-
-    test('Handles single package', () => {
-        const input = 'pip v24.0\n';
-        const result = parseUvTree(input);
-        assert.deepStrictEqual(result, ['pip']);
-    });
-
-    test('Trims leading whitespace from indented lines', () => {
-        const input = '  requests v2.31.0\n  flask v3.0.0\n';
-        const result = parseUvTree(input);
-        assert.deepStrictEqual(result, ['requests', 'flask']);
-    });
-});
diff --git a/src/test/managers/builtin/pipPackageManager.unit.test.ts b/src/test/managers/builtin/pipPackageManager.unit.test.ts
new file mode 100644
index 000000000..9b39938f0
--- /dev/null
+++ b/src/test/managers/builtin/pipPackageManager.unit.test.ts
@@ -0,0 +1,63 @@
+// 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 { LogOutputChannel } from 'vscode';
+import { PythonEnvironmentApi } from '../../../api';
+import * as windowApis from '../../../common/window.apis';
+import * as helpers from '../../../managers/builtin/helpers';
+import { PipPackageManager } from '../../../managers/builtin/pipPackageManager';
+import { VenvManager } from '../../../managers/builtin/venvManager';
+import * as packageChanges from '../../../managers/common/packageChanges';
+import { createMockLogOutputChannel } from '../../mocks/helper';
+import { createMockPythonEnvironment } from '../../mocks/pythonEnvironment';
+
+suite('PipPackageManager', () => {
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('rejects package management for Python 2 environments', async () => {
+        const shouldUseUvStub = sinon.stub(helpers, 'shouldUseUv');
+        const environment = createMockPythonEnvironment({
+            envPath: path.join(process.cwd(), 'python2'),
+            version: '2.7.18',
+            managerId: 'ms-python.python:venv',
+        });
+        const manager = new PipPackageManager(
+            {} as PythonEnvironmentApi,
+            {} as LogOutputChannel,
+            {} as VenvManager,
+        );
+
+        await assert.rejects(
+            manager.manage(environment, { install: ['flask'] }),
+            /Python 2\.\* is not supported \(deprecated\)/,
+        );
+        assert.strictEqual(shouldUseUvStub.callCount, 0);
+    });
+
+    test('uses an uninstall-specific progress title', async () => {
+        const withProgressStub = sinon
+            .stub(windowApis, 'withProgress')
+            .callsFake((_options, task) => task({} as never, {} as never));
+        sinon.stub(helpers, 'shouldUseUv').resolves(false);
+        sinon.stub(helpers, 'runPython').resolves('');
+        sinon.stub(packageChanges, 'updatePackagesAndNotify').resolves([]);
+        const environment = createMockPythonEnvironment({
+            envPath: path.join(process.cwd(), '.venv'),
+            managerId: 'ms-python.python:venv',
+        });
+        const manager = new PipPackageManager(
+            {} as PythonEnvironmentApi,
+            createMockLogOutputChannel(),
+            {} as VenvManager,
+        );
+
+        await manager.manage(environment, { uninstall: ['flask'] });
+
+        assert.strictEqual(withProgressStub.firstCall.args[0].title, 'Uninstalling packages');
+    });
+});
diff --git a/src/test/managers/builtin/pipVersions.unit.test.ts b/src/test/managers/builtin/pipVersions.unit.test.ts
deleted file mode 100644
index 5c06c394b..000000000
--- a/src/test/managers/builtin/pipVersions.unit.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import assert from 'assert';
-import { explain } from '@renovatebot/pep440';
-import { parsePipIndexVersionsJson } from '../../../managers/builtin/pipPackageManager';
-
-suite('Pip Version Parsing', () => {
-    suite('parsePipIndexVersionsJson', () => {
-        test('parses valid JSON with versions array', () => {
-            const output = JSON.stringify({ name: 'requests', versions: ['2.31.0', '2.30.0', '2.29.0'] });
-            const versions = parsePipIndexVersionsJson(output);
-            assert.deepStrictEqual(versions, ['2.31.0', '2.30.0', '2.29.0'].map((v) => explain(v)));
-        });
-
-        test('parses output with a single version', () => {
-            const output = JSON.stringify({ name: 'my-package', versions: ['1.0.0'] });
-            const versions = parsePipIndexVersionsJson(output);
-            assert.deepStrictEqual(versions, [explain('1.0.0')]);
-        });
-
-        test('returns undefined for empty versions array', () => {
-            const output = JSON.stringify({ name: 'pkg', versions: [] });
-            const versions = parsePipIndexVersionsJson(output);
-            assert.strictEqual(versions, undefined);
-        });
-
-        test('returns undefined for invalid JSON', () => {
-            const versions = parsePipIndexVersionsJson('not json');
-            assert.strictEqual(versions, undefined);
-        });
-
-        test('returns undefined when versions field is missing', () => {
-            const output = JSON.stringify({ name: 'pkg' });
-            const versions = parsePipIndexVersionsJson(output);
-            assert.strictEqual(versions, undefined);
-        });
-    });
-});
-
diff --git a/src/test/managers/builtin/venvUtils.removeVenv.unit.test.ts b/src/test/managers/builtin/venvUtils.removeVenv.unit.test.ts
index 068eb5dca..912cfcd0e 100644
--- a/src/test/managers/builtin/venvUtils.removeVenv.unit.test.ts
+++ b/src/test/managers/builtin/venvUtils.removeVenv.unit.test.ts
@@ -1,6 +1,15 @@
 import * as assert from 'assert';
+import * as fse from 'fs-extra';
 import * as os from 'os';
 import * as path from 'path';
+import * as sinon from 'sinon';
+import { LogOutputChannel } from 'vscode';
+import { VENV_MANAGER_ID } from '../../../common/constants';
+import * as testing from '../../../common/utils/testing';
+import * as windowApis from '../../../common/window.apis';
+import { removeVenv } from '../../../managers/builtin/venvUtils';
+import * as uvEnvironments from '../../../managers/builtin/uvEnvironments';
+import { createMockPythonEnvironment } from '../../mocks/pythonEnvironment';
 
 suite('venvUtils Path Validation', () => {
     suite('isDriveRoot behavior', () => {
@@ -146,4 +155,40 @@ suite('venvUtils removeVenv validation integration', () => {
             'Should check for pyvenv.cfg in the environment root',
         );
     });
+
+    test('test execution removes the environment without showing a confirmation dialog', async () => {
+        const root = await fse.mkdtemp(path.join(os.tmpdir(), 'venv-remove-'));
+        const envPath = path.join(root, '.venv');
+        const pythonPath =
+            os.platform() === 'win32'
+                ? path.join(envPath, 'Scripts', 'python.exe')
+                : path.join(envPath, 'bin', 'python');
+        await fse.outputFile(path.join(envPath, 'pyvenv.cfg'), '');
+        await fse.outputFile(pythonPath, '');
+
+        const showWarningMessage = sinon.stub(windowApis, 'showWarningMessage');
+        sinon.stub(testing, 'isTestExecution').returns(true);
+        sinon.stub(uvEnvironments, 'removeUvEnvironment').resolves();
+        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => task({} as never, {} as never));
+
+        try {
+            const environment = createMockPythonEnvironment({
+                name: '.venv',
+                envPath: pythonPath,
+                sysPrefix: envPath,
+                version: '3.12.0',
+                managerId: VENV_MANAGER_ID,
+            });
+            const log = {
+                error: sinon.stub(),
+            } as unknown as LogOutputChannel;
+
+            assert.strictEqual(await removeVenv(environment, log), true);
+            assert.strictEqual(showWarningMessage.callCount, 0);
+            assert.strictEqual(await fse.pathExists(envPath), false);
+        } finally {
+            sinon.restore();
+            await fse.remove(root);
+        }
+    });
 });
diff --git a/src/test/managers/poetry/poetryPackageManager.unit.test.ts b/src/test/managers/poetry/poetryPackageManager.unit.test.ts
new file mode 100644
index 000000000..ebbcaa4fc
--- /dev/null
+++ b/src/test/managers/poetry/poetryPackageManager.unit.test.ts
@@ -0,0 +1,67 @@
+// 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 { LogOutputChannel, Uri } from 'vscode';
+import { PythonEnvironmentApi } from '../../../api';
+import * as windowApis from '../../../common/window.apis';
+import * as packageChanges from '../../../managers/common/packageChanges';
+import { PoetryPackageManager } from '../../../managers/poetry/poetryPackageManager';
+import { PoetryManager } from '../../../managers/poetry/poetryManager';
+import * as poetryUtils from '../../../managers/poetry/poetryUtils';
+import * as runPoetryModule from '../../../managers/poetry/commands/runPoetry';
+import { createMockPythonEnvironment } from '../../mocks/pythonEnvironment';
+
+suite('PoetryPackageManager', () => {
+    const environment = createMockPythonEnvironment({
+        envPath: path.join(process.cwd(), '.venv'),
+        managerId: 'ms-python.python:poetry',
+    });
+    let runPoetryStub: sinon.SinonStub;
+    let manager: PoetryPackageManager;
+
+    setup(() => {
+        const api = {
+            getPythonProjects: () => [
+                {
+                    name: 'project',
+                    uri: Uri.file(path.join(process.cwd(), 'project', 'pyproject.toml')),
+                },
+            ],
+        } as unknown as PythonEnvironmentApi;
+        const log = {
+            append: sinon.stub(),
+            error: sinon.stub(),
+            info: sinon.stub(),
+            show: sinon.stub(),
+        } as unknown as LogOutputChannel;
+
+        sinon.stub(poetryUtils, 'getPoetry').resolves('poetry');
+        sinon.stub(windowApis, 'withProgress').callsFake((_options, task) => task({} as never, {} as never));
+        sinon.stub(packageChanges, 'updatePackagesAndNotify').resolves([]);
+        runPoetryStub = sinon.stub(runPoetryModule, 'runPoetry').resolves('');
+        manager = new PoetryPackageManager(api, log, {} as PoetryManager);
+    });
+
+    teardown(() => {
+        manager.dispose();
+        sinon.restore();
+    });
+
+    test('package management inherits the process working directory', async () => {
+        await manager.manage(environment, { install: ['requests'], uninstall: ['flask'] });
+
+        assert.strictEqual(runPoetryStub.callCount, 2);
+        assert.strictEqual(runPoetryStub.firstCall.args[1], undefined);
+        assert.strictEqual(runPoetryStub.secondCall.args[1], undefined);
+    });
+
+    test('direct package listing inherits the process working directory', async () => {
+        await manager.getDirectPackageNames(environment);
+
+        assert.strictEqual(runPoetryStub.callCount, 1);
+        assert.strictEqual(runPoetryStub.firstCall.args[1], undefined);
+    });
+});