activation: respect integration setting precedence (#1897)

## Summary
- resolve `python.useEnvironmentsExtension` using workspace-folder,
workspace, then user precedence
- ignore contributed defaults when deciding whether explicit opt-out
applies

Fixes #1895

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

Author: eleanorjboyd

src/extension.ts

@@ -36,7 +36,6 @@ import {
     onDidChangeTerminalShellIntegration,
     withProgress,
 } from './common/window.apis';
-import { getConfiguration, getWorkspaceFolders } from './common/workspace.apis';
 import { createManagerReady } from './features/common/managerReady';
 import { AutoFindProjects } from './features/creators/autoFindProjects';
 import { ExistingProjects } from './features/creators/existingProjects';
@@ -80,7 +79,10 @@ import { PythonProjectManagerImpl } from './features/projectManager';
 import { reportIssue } from './features/reportIssue';
 import { getPythonApi, setPythonApi } from './extensionApi';
 import { registerCompletionProvider } from './features/settings/settingCompletions';
-import { migrateGlobalDefaultEnvManagerSetting } from './features/settings/settingHelpers';
+import {
+    isEnvironmentsExtensionEnabled,
+    migrateGlobalDefaultEnvManagerSetting,
+} from './features/settings/settingHelpers';
 import { setActivateMenuButtonContext } from './features/terminal/activateMenuButton';
 import { normalizeShellPath } from './features/terminal/shells/common/shellUtils';
 import { createShellEnvProviders, createShellStartupProviders } from './features/terminal/shells/providers';
@@ -124,29 +126,7 @@ import { registerPyenvFeatures } from './managers/pyenv/main';
 export async function activate(context: ExtensionContext): Promise<PythonEnvironmentApi | undefined> {
     // Only skip activation if user explicitly set useEnvironmentsExtension to false.
     // When disabled, the main Python extension handles environments instead (legacy mode).
-    const config = getConfiguration('python');
-    const inspection = config.inspect<boolean>('useEnvironmentsExtension');
-
-    // Check global and workspace-level explicit disables
-    let explicitlyDisabled = inspection?.globalValue === false || inspection?.workspaceValue === false;
-
-    // Also check folder-scoped settings in multi-root workspaces
-    // (inspect() on an unscoped config won't populate workspaceFolderValue reliably)
-    if (!explicitlyDisabled) {
-        const workspaceFolders = getWorkspaceFolders();
-        if (workspaceFolders) {
-            for (const folder of workspaceFolders) {
-                const folderConfig = getConfiguration('python', folder.uri);
-                const folderInspection = folderConfig.inspect<boolean>('useEnvironmentsExtension');
-                if (folderInspection?.workspaceFolderValue === false) {
-                    explicitlyDisabled = true;
-                    break;
-                }
-            }
-        }
-    }
-
-    const useEnvironmentsExtension = !explicitlyDisabled;
+    const useEnvironmentsExtension = isEnvironmentsExtensionEnabled();
     traceInfo(`Experiment Status: useEnvironmentsExtension setting set to ${useEnvironmentsExtension}`);
     if (!useEnvironmentsExtension) {
         traceWarn(

src/features/settings/settingHelpers.ts

@@ -989,6 +989,22 @@ export function getSettingWorkspaceScope<T>(section: string, key: string, scope?
     return undefined;
 }
 
+/**
+ * Determines whether the Python Environments extension should activate.
+ *
+ * Explicit values are resolved independently for each workspace folder using VS Code's
+ * workspace-folder > workspace > user precedence. The extension activates when at least
+ * one folder enables integration, or when no explicit value applies.
+ */
+export function isEnvironmentsExtensionEnabled(): boolean {
+    const workspaceFolders = workspaceApis.getWorkspaceFolders();
+    const scopes = workspaceFolders?.length ? workspaceFolders.map((folder) => folder.uri) : [undefined];
+
+    return scopes.some(
+        (scope) => getSettingWorkspaceScope<boolean>('python', 'useEnvironmentsExtension', scope) !== false,
+    );
+}
+
 /**
  * Gets user-configured setting for user-scoped settings.
  * Only checks globalValue (ignores defaultValue).

src/test/features/settings/settingHelpers.activation.unit.test.ts

@@ -0,0 +1,103 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { Uri, WorkspaceConfiguration, WorkspaceFolder } from 'vscode';
+import * as workspaceApis from '../../../common/workspace.apis';
+import { isEnvironmentsExtensionEnabled } from '../../../features/settings/settingHelpers';
+
+type SettingInspection = {
+    defaultValue?: boolean;
+    globalValue?: boolean;
+    workspaceValue?: boolean;
+    workspaceFolderValue?: boolean;
+};
+
+function createConfiguration(inspection: SettingInspection | undefined): WorkspaceConfiguration {
+    return {
+        inspect: sinon.stub().withArgs('useEnvironmentsExtension').returns(inspection),
+    } as unknown as WorkspaceConfiguration;
+}
+
+function createWorkspaceFolder(name: string, index: number): WorkspaceFolder {
+    return {
+        uri: Uri.joinPath(Uri.file(process.cwd()), name),
+        name,
+        index,
+    };
+}
+
+suite('isEnvironmentsExtensionEnabled', () => {
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('ignores a contributed default when no value is explicitly configured', () => {
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').returns(undefined);
+        sinon
+            .stub(workspaceApis, 'getConfiguration')
+            .withArgs('python', undefined)
+            .returns(createConfiguration({ defaultValue: false }));
+
+        assert.strictEqual(isEnvironmentsExtensionEnabled(), true);
+    });
+
+    test('uses an explicit user false value when no workspace is open', () => {
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').returns(undefined);
+        sinon
+            .stub(workspaceApis, 'getConfiguration')
+            .withArgs('python', undefined)
+            .returns(createConfiguration({ globalValue: false }));
+
+        assert.strictEqual(isEnvironmentsExtensionEnabled(), false);
+    });
+
+    test('uses a workspace true value over a user false value', () => {
+        const workspaceFolder = createWorkspaceFolder('workspace', 0);
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').returns([workspaceFolder]);
+        sinon
+            .stub(workspaceApis, 'getConfiguration')
+            .withArgs('python', workspaceFolder.uri)
+            .returns(createConfiguration({ globalValue: false, workspaceValue: true }));
+
+        assert.strictEqual(isEnvironmentsExtensionEnabled(), true);
+    });
+
+    test('uses a workspace false value over a user true value', () => {
+        const workspaceFolder = createWorkspaceFolder('workspace', 0);
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').returns([workspaceFolder]);
+        sinon
+            .stub(workspaceApis, 'getConfiguration')
+            .withArgs('python', workspaceFolder.uri)
+            .returns(createConfiguration({ globalValue: true, workspaceValue: false }));
+
+        assert.strictEqual(isEnvironmentsExtensionEnabled(), false);
+    });
+
+    test('uses a workspace-folder false value over a workspace true value', () => {
+        const workspaceFolder = createWorkspaceFolder('workspace', 0);
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').returns([workspaceFolder]);
+        sinon
+            .stub(workspaceApis, 'getConfiguration')
+            .withArgs('python', workspaceFolder.uri)
+            .returns(createConfiguration({ workspaceValue: true, workspaceFolderValue: false }));
+
+        assert.strictEqual(isEnvironmentsExtensionEnabled(), false);
+    });
+
+    test('activates when any workspace folder resolves to true', () => {
+        const disabledFolder = createWorkspaceFolder('disabled', 0);
+        const enabledFolder = createWorkspaceFolder('enabled', 1);
+        sinon.stub(workspaceApis, 'getWorkspaceFolders').returns([disabledFolder, enabledFolder]);
+        const getConfiguration = sinon.stub(workspaceApis, 'getConfiguration');
+        getConfiguration
+            .withArgs('python', disabledFolder.uri)
+            .returns(createConfiguration({ workspaceValue: false }));
+        getConfiguration
+            .withArgs('python', enabledFolder.uri)
+            .returns(createConfiguration({ workspaceValue: false, workspaceFolderValue: true }));
+
+        assert.strictEqual(isEnvironmentsExtensionEnabled(), true);
+    });
+});