diff --git a/‎src/features/interpreterSelection.ts‎
Lines changed: 74 additions & 9 deletions b/‎src/features/interpreterSelection.ts‎
Lines changed: 74 additions & 9 deletions
diff --git a/‎src/test/features/interpreterSelection.unit.test.ts‎
Lines changed: 145 additions & 0 deletions b/‎src/test/features/interpreterSelection.unit.test.ts‎
Lines changed: 145 additions & 0 deletions
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import * as fs from 'fs-extra';
 import * as path from 'path';
 import { commands, ConfigurationChangeEvent, Disposable, l10n, Uri } from 'vscode';
 import { PythonEnvironment, PythonEnvironmentApi } from '../api';
@@ -11,6 +12,7 @@ import { EventNames } from '../common/telemetry/constants';
 import { sendTelemetryEvent } from '../common/telemetry/sender';
 import { resolveVariables } from '../common/utils/internalVariables';
 import { normalizePath } from '../common/utils/pathUtils';
+import { isWindows } from '../common/utils/platformUtils';
 import { showWarningMessage } from '../common/window.apis';
 import {
     getConfiguration,
@@ -27,6 +29,12 @@ import type {
 import type { InternalEnvironmentManager } from '../managers/common/registeredManagers';
 import { NativeEnvInfo, NativePythonFinder } from '../managers/common/nativePythonFinder';
 
+/**
+ * The default value of `python.defaultInterpreterPath`. Like the Python extension, treat it as "not
+ * configured" so auto-discovery (which prefers a workspace venv) picks the interpreter.
+ */
+const DEFAULT_INTERPRETER_PATH_SETTING = 'python';
+
 /**
  * Result from the priority chain resolution.
  */
@@ -109,7 +117,11 @@ async function resolvePriorityChainCore(
 
     // PRIORITY 3: User-configured python.defaultInterpreterPath
     const userInterpreterPath = getUserConfiguredSetting<string>('python', 'defaultInterpreterPath', scope);
-    if (userInterpreterPath) {
+    if (userInterpreterPath === DEFAULT_INTERPRETER_PATH_SETTING) {
+        traceVerbose(
+            `${logPrefix} defaultInterpreterPath is the default '${userInterpreterPath}', using auto-discovery`,
+        );
+    } else if (userInterpreterPath) {
         const expandedInterpreterPath = resolveVariables(userInterpreterPath, scope);
         if (expandedInterpreterPath.includes('${')) {
             if (scope) {
@@ -135,7 +147,7 @@ async function resolvePriorityChainCore(
             // Resolve relative paths against the workspace folder so the native finder doesn't
             // resolve them against an unrelated current working directory (which can produce a
             // malformed, duplicated path such as <workspace>/<workspace-name>/.venv/...).
-            const absoluteInterpreterPath = toAbsoluteInterpreterPath(expandedInterpreterPath, scope);
+            const absoluteInterpreterPath = await toAbsoluteInterpreterPath(expandedInterpreterPath, scope);
             const resolved = await tryResolveInterpreterPath(nativeFinder, api, absoluteInterpreterPath, envManagers);
             if (resolved) {
                 traceVerbose(`${logPrefix} Priority 3: Using defaultInterpreterPath: ${userInterpreterPath}`);
@@ -534,24 +546,77 @@ function getProjectSpecificEnvManager(projectManager: PythonProjectManager, scop
 /**
  * Resolve a (variable-expanded) interpreter path to an absolute path.
  *
- * `python.defaultInterpreterPath` may be configured as a relative path (e.g. `.venv/bin/python`).
- * The native finder resolves relative paths against its own working directory, which is unrelated
- * to the workspace and can produce malformed paths (including a duplicated workspace segment).
- * To avoid this, relative paths are resolved against the workspace folder identified by the scope.
- * Global relative paths are left unchanged because there is no workspace context to resolve against.
+ * A bare command name such as `python3` refers to the interpreter found on `PATH`, as in a terminal.
+ * Other relative paths (e.g. `.venv/bin/python`) are resolved against the workspace folder
+ * identified by the scope, because the native finder would resolve them against its own,
+ * unrelated working directory and can produce malformed paths (including a duplicated
+ * workspace segment). Global relative paths are left unchanged because there is no workspace
+ * context to resolve against.
  *
  * @param interpreterPath - The interpreter path after variable substitution.
  * @param scope - The workspace folder URI, or undefined for global scope.
  * @returns An absolute interpreter path when possible, otherwise the input unchanged.
  */
-function toAbsoluteInterpreterPath(interpreterPath: string, scope: Uri | undefined): string {
-    if (path.isAbsolute(interpreterPath) || !scope) {
+async function toAbsoluteInterpreterPath(interpreterPath: string, scope: Uri | undefined): Promise<string> {
+    if (path.isAbsolute(interpreterPath)) {
+        return interpreterPath;
+    }
+    if (!/[\\/]/.test(interpreterPath)) {
+        const onPath = await findCommandOnPath(interpreterPath);
+        if (onPath) {
+            return onPath;
+        }
+    }
+    if (!scope) {
         return interpreterPath;
     }
     const workspaceFolder = getWorkspaceFolder(scope);
     return path.resolve(workspaceFolder?.uri.fsPath ?? scope.fsPath, interpreterPath);
 }
 
+/**
+ * Finds an executable on `PATH` and returns its absolute path.
+ *
+ * On Windows only `.com` and `.exe` files are considered, as when a process is started without a
+ * shell; batch-file shims cannot be launched that way. Unlike `which`, this accepts Windows App
+ * Execution Aliases (the `python.exe` that the Microsoft Store and the Python install manager place
+ * in `WindowsApps`), which exist but cannot be `stat`ed. Relative `PATH` entries are skipped because
+ * they would resolve against the extension host's working directory.
+ */
+async function findCommandOnPath(command: string): Promise<string | undefined> {
+    const extensions = isWindows() ? ['.com', '.exe'] : [''];
+    const names =
+        isWindows() && extensions.some((ext) => command.toLowerCase().endsWith(ext))
+            ? [command]
+            : extensions.map((ext) => command + ext);
+    for (const entry of (process.env.PATH ?? '').split(path.delimiter)) {
+        const dir = entry.replace(/^"(.*)"$/, '$1');
+        if (!dir || !path.isAbsolute(dir)) {
+            continue;
+        }
+        for (const name of names) {
+            const candidate = path.join(dir, name);
+            if (await isCommandFile(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return undefined;
+}
+
+async function isCommandFile(candidate: string): Promise<boolean> {
+    try {
+        if (isWindows()) {
+            await fs.access(candidate, fs.constants.F_OK);
+            return true;
+        }
+        await fs.access(candidate, fs.constants.X_OK);
+        return (await fs.stat(candidate)).isFile();
+    } catch {
+        return false;
+    }
+}
+
 /**
  * Try to resolve an interpreter path via nativeFinder and return a PriorityChainResult.
  * Returns undefined if resolution fails.
 
@@ -2,10 +2,13 @@
 // Licensed under the MIT License.
 
 import * as 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 { ConfigurationChangeEvent, Uri, WorkspaceConfiguration, WorkspaceFolder } from 'vscode';
 import { PythonEnvironment, PythonEnvironmentApi, PythonProject, SetEnvironmentScope } from '../../api';
+import { normalizePath } from '../../common/utils/pathUtils';
 import * as windowApis from '../../common/window.apis';
 import * as workspaceApis from '../../common/workspace.apis';
 import {
@@ -396,6 +399,148 @@ suite('Interpreter Selection - Priority Chain', () => {
             assert.ok(mockNativeFinder.resolve.calledOnceWithExactly(absoluteInterpreterPath));
         });
 
+        suite('bare command names', () => {
+            let commandDir: string;
+            let originalPath: string | undefined;
+
+            /** Creates an executable named `name` in a temporary directory placed first on PATH. */
+            async function putCommandOnPath(name: string): Promise<string> {
+                commandDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dip-command-'));
+                const executable = path.join(commandDir, process.platform === 'win32' ? `${name}.exe` : name);
+                await fs.writeFile(executable, '');
+                await fs.chmod(executable, 0o755);
+                originalPath = process.env.PATH;
+                process.env.PATH = `${commandDir}${path.delimiter}${originalPath ?? ''}`;
+                return executable;
+            }
+
+            function useDefaultInterpreterPath(value: string): void {
+                sandbox
+                    .stub(helpers, 'getUserConfiguredSetting')
+                    .callsFake((section: string, key: string) =>
+                        section === 'python' && key === 'defaultInterpreterPath' ? value : undefined,
+                    );
+            }
+
+            teardown(async () => {
+                if (originalPath !== undefined) {
+                    process.env.PATH = originalPath;
+                    originalPath = undefined;
+                }
+                if (commandDir) {
+                    await fs.remove(commandDir);
+                }
+            });
+
+            for (const testCase of [
+                {
+                    scope: 'workspace folder',
+                    resolve: async () => {
+                        const workspaceUri = Uri.file(path.resolve('test', 'workspace'));
+                        const workspaceFolder = { name: 'workspace', uri: workspaceUri } as WorkspaceFolder;
+                        sandbox
+                            .stub(workspaceApis, 'getConfiguration')
+                            .returns(createMockConfig([]) as WorkspaceConfiguration);
+                        sandbox.stub(workspaceApis, 'getWorkspaceFolder').returns(workspaceFolder);
+                        sandbox.stub(workspaceApis, 'getWorkspaceFolders').returns([workspaceFolder]);
+                        return resolveEnvironmentByPriority(
+                            workspaceUri,
+                            mockEnvManagers as unknown as EnvironmentManagers,
+                            mockProjectManager as unknown as PythonProjectManager,
+                            mockNativeFinder as unknown as NativePythonFinder,
+                            mockApi as unknown as PythonEnvironmentApi,
+                        );
+                    },
+                },
+                {
+                    scope: 'global scope',
+                    resolve: async () => {
+                        sandbox.stub(workspaceApis, 'getWorkspaceFolders').returns([]);
+                        return resolveGlobalEnvironmentByPriority(
+                            mockEnvManagers as unknown as EnvironmentManagers,
+                            mockNativeFinder as unknown as NativePythonFinder,
+                            mockApi as unknown as PythonEnvironmentApi,
+                        );
+                    },
+                },
+            ]) {
+                test(`should resolve a command name from PATH for the ${testCase.scope}`, async () => {
+                    const executable = await putCommandOnPath('pyenvs-test-python3');
+                    useDefaultInterpreterPath('pyenvs-test-python3');
+                    mockNativeFinder.resolve.resolves({ executable, version: '3.12.4', prefix: commandDir });
+                    mockApi.resolveEnvironment.resolves(mockSystemEnv);
+
+                    const result = await testCase.resolve();
+
+                    assert.strictEqual(result.source, 'defaultInterpreterPath');
+                    assert.strictEqual(
+                        normalizePath(mockNativeFinder.resolve.firstCall.args[0]),
+                        normalizePath(executable),
+                    );
+                });
+            }
+
+            test('should resolve a command name that is not on PATH against the workspace folder', async () => {
+                const workspaceUri = Uri.file(path.resolve('test', 'workspace'));
+                const workspaceFolder = { name: 'workspace', uri: workspaceUri } as WorkspaceFolder;
+                const expected = path.resolve(workspaceUri.fsPath, 'pyenvs-test-missing-python');
+                sandbox.stub(workspaceApis, 'getConfiguration').returns(createMockConfig([]) as WorkspaceConfiguration);
+                sandbox.stub(workspaceApis, 'getWorkspaceFolder').returns(workspaceFolder);
+                sandbox.stub(workspaceApis, 'getWorkspaceFolders').returns([workspaceFolder]);
+                useDefaultInterpreterPath('pyenvs-test-missing-python');
+                mockNativeFinder.resolve.rejects(new Error('not found'));
+                mockVenvManager.get.resolves(undefined);
+
+                await resolveEnvironmentByPriority(
+                    workspaceUri,
+                    mockEnvManagers as unknown as EnvironmentManagers,
+                    mockProjectManager as unknown as PythonProjectManager,
+                    mockNativeFinder as unknown as NativePythonFinder,
+                    mockApi as unknown as PythonEnvironmentApi,
+                );
+
+                assert.ok(mockNativeFinder.resolve.calledOnceWithExactly(expected));
+            });
+
+            test('should treat the default value "python" as not configured', async () => {
+                await putCommandOnPath('python');
+                sandbox.stub(workspaceApis, 'getConfiguration').returns(createMockConfig([]) as WorkspaceConfiguration);
+                useDefaultInterpreterPath('python');
+                mockVenvManager.get.resolves(mockVenvEnv);
+
+                const result = await resolveEnvironmentByPriority(
+                    testUri,
+                    mockEnvManagers as unknown as EnvironmentManagers,
+                    mockProjectManager as unknown as PythonProjectManager,
+                    mockNativeFinder as unknown as NativePythonFinder,
+                    mockApi as unknown as PythonEnvironmentApi,
+                );
+
+                assert.strictEqual(result.source, 'autoDiscovery');
+                assert.strictEqual(result.environment, mockVenvEnv);
+                assert.ok(mockNativeFinder.resolve.notCalled);
+            });
+
+            test('should not pick a batch file from PATH on Windows', async function () {
+                if (process.platform !== 'win32') {
+                    this.skip();
+                }
+                const shim = await putCommandOnPath('pyenvs-test-shim');
+                await fs.move(shim, path.join(commandDir, 'pyenvs-test-shim.bat'));
+                sandbox.stub(workspaceApis, 'getWorkspaceFolders').returns([]);
+                useDefaultInterpreterPath('pyenvs-test-shim');
+                mockNativeFinder.resolve.rejects(new Error('not found'));
+
+                await resolveGlobalEnvironmentByPriority(
+                    mockEnvManagers as unknown as EnvironmentManagers,
+                    mockNativeFinder as unknown as NativePythonFinder,
+                    mockApi as unknown as PythonEnvironmentApi,
+                );
+
+                assert.ok(mockNativeFinder.resolve.calledOnceWithExactly('pyenvs-test-shim'));
+            });
+        });
+
         test('should pass an absolute defaultInterpreterPath to the native finder unchanged', async () => {
             // Absolute paths must not be re-resolved against the workspace folder.
             const workspaceUri = Uri.file(path.resolve('/test/workspace'));