diff --git a/.config/CredScanSuppressions.json b/.config/CredScanSuppressions.json
deleted file mode 100644
index cc237f71d86c..000000000000
--- a/.config/CredScanSuppressions.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-    "tool": "Credential Scanner",
-    "suppressions": [
-      {
-        "file": [
-          "file:///mnt/vss/_work/1/a/extension/extension/.nox/install_python_libs/lib/python3.8/site-packages/setuptools/_distutils/command%5Cregister.py",
-          "file:///mnt/vss/_work/1/b/extension/extension/.nox/install_python_libs/lib/python3.8/site-packages/setuptools/_distutils/command%5Cregister.py"
-        ],
-        "_justification": "These are not real passwords. For documentation purposes only."
-      }
-    ]
-  }
diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index 3e7e9e9cf091..ffc0150ebac5 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/devcontainers/typescript-node:18-bookworm
+FROM mcr.microsoft.com/devcontainers/typescript-node:22-bookworm
 
 RUN apt-get install -y wget bzip2
 
diff --git a/.github/actions/build-vsix/action.yml b/.github/actions/build-vsix/action.yml
index 929ecb31a6d3..912ff2c34a74 100644
--- a/.github/actions/build-vsix/action.yml
+++ b/.github/actions/build-vsix/action.yml
@@ -22,7 +22,7 @@ runs:
   using: 'composite'
   steps:
     - name: Install Node
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v6
       with:
         node-version: ${{ inputs.node_version }}
         cache: 'npm'
@@ -31,10 +31,10 @@ runs:
       uses: dtolnay/rust-toolchain@stable
 
     # Jedi LS depends on dataclasses which is not in the stdlib in Python 3.7.
-    - name: Use Python 3.8 for JediLSP
-      uses: actions/setup-python@v5
+    - name: Use Python 3.10 for JediLSP
+      uses: actions/setup-python@v6
       with:
-        python-version: 3.8
+        python-version: '3.10'
         cache: 'pip'
         cache-dependency-path: |
           requirements.txt
@@ -54,8 +54,10 @@ runs:
       shell: bash
 
     - name: Add Rustup target
-      run: rustup target add ${{ inputs.cargo_target }}
+      run: rustup target add "${CARGO_TARGET}"
       shell: bash
+      env:
+        CARGO_TARGET: ${{ inputs.cargo_target }}
 
     - name: Build Native Binaries
       run: nox --session native_build
@@ -78,16 +80,20 @@ runs:
       shell: bash
 
     - name: Build VSIX
-      run: npx vsce package --target ${{ inputs.vsix_target }} --out ms-python-insiders.vsix --pre-release
+      run: npx vsce package --target "${VSIX_TARGET}" --out ms-python-insiders.vsix --pre-release
       shell: bash
+      env:
+        VSIX_TARGET: ${{ inputs.vsix_target }}
 
     - name: Rename VSIX
       # Move to a temp name in case the specified name happens to match the default name.
-      run: mv ms-python-insiders.vsix ms-python-temp.vsix && mv ms-python-temp.vsix ${{ inputs.vsix_name }}
+      run: mv ms-python-insiders.vsix ms-python-temp.vsix && mv ms-python-temp.vsix "${VSIX_NAME}"
       shell: bash
+      env:
+        VSIX_NAME: ${{ inputs.vsix_name }}
 
     - name: Upload VSIX
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: ${{ inputs.artifact_name }}
         path: ${{ inputs.vsix_name }}
diff --git a/.github/actions/lint/action.yml b/.github/actions/lint/action.yml
index 9992b442c276..0bd5a2d8e1e2 100644
--- a/.github/actions/lint/action.yml
+++ b/.github/actions/lint/action.yml
@@ -10,7 +10,7 @@ runs:
   using: 'composite'
   steps:
     - name: Install Node
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v6
       with:
         node-version: ${{ inputs.node_version }}
         cache: 'npm'
@@ -36,7 +36,7 @@ runs:
       shell: bash
 
     - name: Install Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: '3.x'
         cache: 'pip'
diff --git a/.github/actions/smoke-tests/action.yml b/.github/actions/smoke-tests/action.yml
index 2463f83ee90c..0531ef5d42a3 100644
--- a/.github/actions/smoke-tests/action.yml
+++ b/.github/actions/smoke-tests/action.yml
@@ -13,13 +13,13 @@ runs:
   using: 'composite'
   steps:
     - name: Install Node
-      uses: actions/setup-node@v2
+      uses: actions/setup-node@v4
       with:
         node-version: ${{ inputs.node_version }}
         cache: 'npm'
 
     - name: Install Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
         cache: 'pip'
@@ -32,7 +32,7 @@ runs:
       shell: bash
 
     - name: Install Python requirements
-      uses: brettcannon/pip-secure-install@v1
+      uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
       with:
         options: '-t ./python_files/lib/python --implementation py'
 
@@ -61,6 +61,6 @@ runs:
       env:
         DISPLAY: 10
         INSTALL_JUPYTER_EXTENSION: true
-      uses: GabrielBB/xvfb-action@v1.7
+      uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
       with:
         run: node --no-force-async-hooks-checks ./out/test/smokeTest.js
diff --git a/.github/commands.json b/.github/commands.json
index 2fb6684a7ee6..171f33f380c3 100644
--- a/.github/commands.json
+++ b/.github/commands.json
@@ -153,5 +153,14 @@
 		"addLabel": "info-needed",
 		"removeLabel": "~confirmation-needed",
 		"comment": "Please diagnose the root cause of the issue by running the command `F1 > Help: Troubleshoot Issue` and following the instructions. Once you have done that, please update the issue with the results.\n\nHappy Coding!"
+	},
+    {
+		"type": "label",
+		"name": "~spam",
+		"removeLabel": "~spam",
+		"addLabel": "spam",
+		"action": "close",
+		"reason": "not_planned",
+		"comment": "Thank you for your submission. This issue has been closed as it doesn't meet our community guidelines or appears to be spam.\n\n**If you believe this was closed in error:**\n- Please review our [Code of Conduct](https://opensource.microsoft.com/codeofconduct/)\n- Ensure your issue contains a clear description of the problem or feature request\n- Feel free to open a new issue with appropriate detail if this was a legitimate concern\n\n**For legitimate issues, please include:**\n- Clear description of the problem\n- Steps to reproduce (for bugs)\n- Expected vs actual behavior\n- VS Code version and environment details\n\nThank you for helping us maintain a welcoming and productive community."
 	}
 ]
diff --git a/.github/instructions/learning.instructions.md b/.github/instructions/learning.instructions.md
new file mode 100644
index 000000000000..28b085f486ce
--- /dev/null
+++ b/.github/instructions/learning.instructions.md
@@ -0,0 +1,34 @@
+---
+applyTo: '**'
+description: This document describes how to deal with learnings that you make. (meta instruction)
+---
+
+This document describes how to deal with learnings that you make.
+It is a meta-instruction file.
+
+Structure of learnings:
+
+-   Each instruction file has a "Learnings" section.
+-   Each learning has a counter that indicates how often that learning was useful (initially 1).
+-   Each learning has a 1 sentence description of the learning that is clear and concise.
+
+Example:
+
+```markdown
+## Learnings
+
+-   Prefer `const` over `let` whenever possible (1)
+-   Avoid `any` type (3)
+```
+
+When the user tells you "learn!", you should:
+
+-   extract a learning from the recent conversation
+    _ identify the problem that you created
+    _ identify why it was a problem
+    _ identify how you were told to fix it/how the user fixed it
+    _ generate only one learning (1 sentence) that helps to summarize the insight gained
+-   then, add the reflected learning to the "Learnings" section of the most appropriate instruction file
+
+Important: Whenever a learning was really useful, increase the counter!!
+When a learning was not useful and just caused more problems, decrease the counter.
diff --git a/.github/instructions/pytest-json-test-builder.instructions.md b/.github/instructions/pytest-json-test-builder.instructions.md
new file mode 100644
index 000000000000..436bce0c9cd8
--- /dev/null
+++ b/.github/instructions/pytest-json-test-builder.instructions.md
@@ -0,0 +1,126 @@
+---
+applyTo: 'python_files/tests/pytestadapter/test_discovery.py'
+description: 'A guide for adding new tests for pytest discovery and JSON formatting in the test_pytest_collect suite.'
+---
+
+# How to Add New Pytest Discovery Tests
+
+This guide explains how to add new tests for pytest discovery and JSON formatting in the `test_pytest_collect` suite. Follow these steps to ensure your tests are consistent and correct.
+
+---
+
+## 1. Add Your Test File
+
+-   Place your new test file/files in the appropriate subfolder under:
+    ```
+    python_files/tests/pytestadapter/.data/
+    ```
+-   Organize folders and files to match the structure you want to test. For example, to test nested folders, create the corresponding directory structure.
+-   In your test file, mark each test function with a comment:
+    ```python
+    def test_function():  # test_marker--test_function
+        ...
+    ```
+
+**Root Node Matching:**
+
+-   The root node in your expected output must match the folder or file you pass to pytest discovery. For example, if you run discovery on a subfolder, the root `"name"`, `"path"`, and `"id_"` in your expected output should be that subfolder, not the parent `.data` folder.
+-   Only use `.data` as the root if you are running discovery on the entire `.data` folder.
+
+**Example:**
+If you run:
+
+```python
+helpers.runner([os.fspath(TEST_DATA_PATH / "myfolder"), "--collect-only"])
+```
+
+then your expected output root should be:
+
+```python
+{
+    "name": "myfolder",
+    "path": os.fspath(TEST_DATA_PATH / "myfolder"),
+    "type_": "folder",
+    ...
+}
+```
+
+---
+
+## 2. Update `expected_discovery_test_output.py`
+
+-   Open `expected_discovery_test_output.py` in the same test suite.
+-   Add a new expected output dictionary for your test file, following the format of existing entries.
+-   Use the helper functions and path conventions:
+    -   Use `os.fspath()` for all paths.
+    -   Use `find_test_line_number("function_name", file_path)` for the `lineno` field.
+    -   Use `get_absolute_test_id("relative_path::function_name", file_path)` for `id_` and `runID`.
+    -   Always use current path concatenation (e.g., `TEST_DATA_PATH / "your_folder" / "your_file.py"`).
+    -   Create new constants as needed to keep the code clean and maintainable.
+
+**Important:**
+
+-   Do **not** read the entire `expected_discovery_test_output.py` file if you only need to add or reference a single constant. This file is very large; prefer searching for the relevant section or appending to the end.
+
+**Example:**
+If you run discovery on a subfolder:
+
+```python
+helpers.runner([os.fspath(TEST_DATA_PATH / "myfolder"), "--collect-only"])
+```
+
+then your expected output root should be:
+
+```python
+myfolder_path = TEST_DATA_PATH / "myfolder"
+my_expected_output = {
+    "name": "myfolder",
+    "path": os.fspath(myfolder_path),
+    "type_": "folder",
+    ...
+}
+```
+
+-   Add a comment above your dictionary describing the structure, as in the existing examples.
+
+---
+
+## 3. Add Your Test to `test_discovery.py`
+
+-   In `test_discovery.py`, add your new test as a parameterized case to the main `test_pytest_collect` function. Do **not** create a standalone test function for new discovery cases.
+-   Reference your new expected output constant from `expected_discovery_test_output.py`.
+
+**Example:**
+
+```python
+@pytest.mark.parametrize(
+    ("file", "expected_const"),
+    [
+        ("myfolder", my_expected_output),
+        # ... other cases ...
+    ],
+)
+def test_pytest_collect(file, expected_const):
+    ...
+```
+
+---
+
+## 4. Run and Verify
+
+-   Run the test suite to ensure your new test is discovered and passes.
+-   If the test fails, check your expected output dictionary for path or structure mismatches.
+
+---
+
+## 5. Tips
+
+-   Always use the helper functions for line numbers and IDs.
+-   Match the folder/file structure in `.data` to the expected JSON structure.
+-   Use comments to document the expected output structure for clarity.
+-   Ensure all `"path"` and `"id_"` fields in your expected output match exactly what pytest returns, including absolute paths and root node structure.
+
+---
+
+**Reference:**
+See `expected_discovery_test_output.py` for more examples and formatting. Use search or jump to the end of the file to avoid reading the entire file when possible.
diff --git a/.github/instructions/python-quality-checks.instructions.md b/.github/instructions/python-quality-checks.instructions.md
new file mode 100644
index 000000000000..48f37529dfbc
--- /dev/null
+++ b/.github/instructions/python-quality-checks.instructions.md
@@ -0,0 +1,97 @@
+---
+applyTo: 'python_files/**'
+description: Guide for running and fixing Python quality checks (Ruff and Pyright) that run in CI
+---
+
+# Python Quality Checks — Ruff and Pyright
+
+Run the same Python quality checks that run in CI. All checks target `python_files/` and use config from `python_files/pyproject.toml`.
+
+## Commands
+
+```bash
+npm run check-python              # Run both Ruff and Pyright
+npm run check-python:ruff         # Linting and formatting only
+npm run check-python:pyright      # Type checking only
+```
+
+## Fixing Ruff Errors
+
+**Auto-fix most issues:**
+
+```bash
+cd python_files
+python -m ruff check . --fix
+python -m ruff format
+npm run check-python:ruff  # Verify
+```
+
+**Manual fixes:**
+
+-   Ruff shows file, line number, rule code (e.g., `F841`), and description
+-   Open the file, read the error, fix the code
+-   Common: line length (100 char max), import sorting, unused variables
+
+## Fixing Pyright Errors
+
+**Common patterns and fixes:**
+
+-   **Undefined variable/import**: Add the missing import
+-   **Type mismatch**: Correct the type or add type annotations
+-   **Missing return type**: Add `-> ReturnType` to function signatures
+    ```python
+    def my_function() -> str:  # Add return type
+        return "result"
+    ```
+
+**Verify:**
+
+```bash
+npm run check-python:pyright
+```
+
+## Configuration
+
+-   **Ruff**: Line length 100, Python 3.9+, 40+ rule families (flake8, isort, pyupgrade, etc.)
+-   **Pyright**: Version 1.1.308 (or whatever is found in the environment), ignores `lib/` and 15+ legacy files
+-   Config: `python_files/pyproject.toml` sections `[tool.ruff]` and `[tool.pyright]`
+
+## Troubleshooting
+
+**"Module not found" in Pyright**: Install dependencies
+
+```bash
+python -m pip install --upgrade -r build/test-requirements.txt
+nox --session install_python_libs
+```
+
+**Import order errors**: Auto-fix with `ruff check . --fix`
+
+**Type errors in ignored files**: Legacy files in `pyproject.toml` ignore list—fix if working on them
+
+## When Writing Tests
+
+**Always format your test files before committing:**
+
+```bash
+cd python_files
+ruff format tests/  # Format all test files
+# or format specific files:
+ruff format tests/unittestadapter/test_utils.py
+```
+
+**Best practice workflow:**
+
+1. Write your test code
+2. Run `ruff format` on the test files
+3. Run the tests to verify they pass
+4. Run `npm run check-python` to catch any remaining issues
+
+This ensures your tests pass both functional checks and quality checks in CI.
+
+## Learnings
+
+-   Always run `npm run check-python` before pushing to catch CI failures early (1)
+-   Use `ruff check . --fix` to auto-fix most linting issues before manual review (1)
+-   Pyright version must match CI (1.1.308) to avoid inconsistent results between local and CI runs (1)
+-   Always run `ruff format` on test files after writing them to avoid formatting CI failures (1)
diff --git a/.github/instructions/testing-workflow.instructions.md b/.github/instructions/testing-workflow.instructions.md
new file mode 100644
index 000000000000..844946404328
--- /dev/null
+++ b/.github/instructions/testing-workflow.instructions.md
@@ -0,0 +1,581 @@
+---
+applyTo: '**/test/**'
+---
+
+# AI Testing Workflow Guide: Write, Run, and Fix Tests
+
+This guide provides comprehensive instructions for AI agents on the complete testing workflow: writing tests, running them, diagnosing failures, and fixing issues. Use this guide whenever working with test files or when users request testing tasks.
+
+## Complete Testing Workflow
+
+This guide covers the full testing lifecycle:
+
+1. **📝 Writing Tests** - Create comprehensive test suites
+2. **▶️ Running Tests** - Execute tests using VS Code tools
+3. **🔍 Diagnosing Issues** - Analyze failures and errors
+4. **🛠️ Fixing Problems** - Resolve compilation and runtime issues
+5. **✅ Validation** - Ensure coverage and resilience
+
+### When to Use This Guide
+
+**User Requests Testing:**
+
+-   "Write tests for this function"
+-   "Run the tests"
+-   "Fix the failing tests"
+-   "Test this code"
+-   "Add test coverage"
+
+**File Context Triggers:**
+
+-   Working in `**/test/**` directories
+-   Files ending in `.test.ts` or `.unit.test.ts`
+-   Test failures or compilation errors
+-   Coverage reports or test output analysis
+
+## Test Types
+
+When implementing tests as an AI agent, choose between two main types:
+
+### Unit Tests (`*.unit.test.ts`)
+
+-   **Fast isolated testing** - Mock all external dependencies
+-   **Use for**: Pure functions, business logic, data transformations
+-   **Execute with**: `runTests` tool with specific file patterns
+-   **Mock everything** - VS Code APIs automatically mocked via `/src/test/unittests.ts`
+
+### Extension Tests (`*.test.ts`)
+
+-   **Full VS Code integration** - Real environment with actual APIs
+-   **Use for**: Command registration, UI interactions, extension lifecycle
+-   **Execute with**: VS Code launch configurations or `runTests` tool
+-   **Slower but comprehensive** - Tests complete user workflows
+
+## 🤖 Agent Tool Usage for Test Execution
+
+### Primary Tool: `runTests`
+
+Use the `runTests` tool to execute tests programmatically rather than terminal commands for better integration and result parsing:
+
+```typescript
+// Run specific test files
+await runTests({
+    files: ['/absolute/path/to/test.unit.test.ts'],
+    mode: 'run',
+});
+
+// Run tests with coverage
+await runTests({
+    files: ['/absolute/path/to/test.unit.test.ts'],
+    mode: 'coverage',
+    coverageFiles: ['/absolute/path/to/source.ts'],
+});
+
+// Run specific test names
+await runTests({
+    files: ['/absolute/path/to/test.unit.test.ts'],
+    testNames: ['should handle edge case', 'should validate input'],
+});
+```
+
+### Compilation Requirements
+
+Before running tests, ensure compilation. Always start compilation with `npm run watch-tests` before test execution to ensure TypeScript files are built. Recompile after making import/export changes before running tests, as stubs won't work if they're applied to old compiled JavaScript that doesn't have the updated imports:
+
+```typescript
+// Start watch mode for auto-compilation
+await run_in_terminal({
+    command: 'npm run watch-tests',
+    isBackground: true,
+    explanation: 'Start test compilation in watch mode',
+});
+
+// Or compile manually
+await run_in_terminal({
+    command: 'npm run compile-tests',
+    isBackground: false,
+    explanation: 'Compile TypeScript test files',
+});
+```
+
+### Alternative: Terminal Execution
+
+For targeted test runs when `runTests` tool is unavailable. Note: When a targeted test run yields 0 tests, first verify the compiled JS exists under `out/test` (rootDir is `src`); absence almost always means the test file sits outside `src` or compilation hasn't run yet:
+
+```typescript
+// Run specific test suite
+await run_in_terminal({
+    command: 'npm run unittest -- --grep "Suite Name"',
+    isBackground: false,
+    explanation: 'Run targeted unit tests',
+});
+```
+
+## 🔍 Diagnosing Test Failures
+
+### Common Failure Patterns
+
+**Compilation Errors:**
+
+```typescript
+// Missing imports
+if (error.includes('Cannot find module')) {
+    await addMissingImports(testFile);
+}
+
+// Type mismatches
+if (error.includes("Type '" && error.includes("' is not assignable"))) {
+    await fixTypeIssues(testFile);
+}
+```
+
+**Runtime Errors:**
+
+```typescript
+// Mock setup issues
+if (error.includes('stub') || error.includes('mock')) {
+    await fixMockConfiguration(testFile);
+}
+
+// Assertion failures
+if (error.includes('AssertionError')) {
+    await analyzeAssertionFailure(error);
+}
+```
+
+### Systematic Failure Analysis
+
+Fix test issues iteratively - run tests, analyze failures, apply fixes, repeat until passing. When unit tests fail with VS Code API errors like `TypeError: X is not a constructor` or `Cannot read properties of undefined (reading 'Y')`, check if VS Code APIs are properly mocked in `/src/test/unittests.ts` - add missing APIs following the existing pattern.
+
+```typescript
+interface TestFailureAnalysis {
+    type: 'compilation' | 'runtime' | 'assertion' | 'timeout';
+    message: string;
+    location: { file: string; line: number; col: number };
+    suggestedFix: string;
+}
+
+function analyzeFailure(failure: TestFailure): TestFailureAnalysis {
+    if (failure.message.includes('Cannot find module')) {
+        return {
+            type: 'compilation',
+            message: failure.message,
+            location: failure.location,
+            suggestedFix: 'Add missing import statement',
+        };
+    }
+    // ... other failure patterns
+}
+```
+
+### Agent Decision Logic for Test Type Selection
+
+**Choose Unit Tests (`*.unit.test.ts`) when analyzing:**
+
+-   Functions with clear inputs/outputs and no VS Code API dependencies
+-   Data transformation, parsing, or utility functions
+-   Business logic that can be isolated with mocks
+-   Error handling scenarios with predictable inputs
+
+**Choose Extension Tests (`*.test.ts`) when analyzing:**
+
+-   Functions that register VS Code commands or use `vscode.*` APIs
+-   UI components, tree views, or command palette interactions
+-   File system operations requiring workspace context
+-   Extension lifecycle events (activation, deactivation)
+
+**Agent Implementation Pattern:**
+
+```typescript
+function determineTestType(functionCode: string): 'unit' | 'extension' {
+    if (
+        functionCode.includes('vscode.') ||
+        functionCode.includes('commands.register') ||
+        functionCode.includes('window.') ||
+        functionCode.includes('workspace.')
+    ) {
+        return 'extension';
+    }
+    return 'unit';
+}
+```
+
+## 🎯 Step 1: Automated Function Analysis
+
+As an AI agent, analyze the target function systematically:
+
+### Code Analysis Checklist
+
+```typescript
+interface FunctionAnalysis {
+    name: string;
+    inputs: string[]; // Parameter types and names
+    outputs: string; // Return type
+    dependencies: string[]; // External modules/APIs used
+    sideEffects: string[]; // Logging, file system, network calls
+    errorPaths: string[]; // Exception scenarios
+    testType: 'unit' | 'extension';
+}
+```
+
+### Analysis Implementation
+
+1. **Read function source** using `read_file` tool
+2. **Identify imports** - look for `vscode.*`, `child_process`, `fs`, etc.
+3. **Map data flow** - trace inputs through transformations to outputs
+4. **Catalog dependencies** - external calls that need mocking
+5. **Document side effects** - logging, file operations, state changes
+
+### Test Setup Differences
+
+#### Unit Test Setup (\*.unit.test.ts)
+
+```typescript
+// Mock VS Code APIs - handled automatically by unittests.ts
+import * as sinon from 'sinon';
+import * as workspaceApis from '../../common/workspace.apis'; // Wrapper functions
+
+// Stub wrapper functions, not VS Code APIs directly
+// Always mock wrapper functions (e.g., workspaceApis.getConfiguration()) instead of
+// VS Code APIs directly to avoid stubbing issues
+const mockGetConfiguration = sinon.stub(workspaceApis, 'getConfiguration');
+```
+
+#### Extension Test Setup (\*.test.ts)
+
+```typescript
+// Use real VS Code APIs
+import * as vscode from 'vscode';
+
+// Real VS Code APIs available - no mocking needed
+const config = vscode.workspace.getConfiguration('python');
+```
+
+## 🎯 Step 2: Generate Test Coverage Matrix
+
+Based on function analysis, automatically generate comprehensive test scenarios:
+
+### Coverage Matrix Generation
+
+```typescript
+interface TestScenario {
+    category: 'happy-path' | 'edge-case' | 'error-handling' | 'side-effects';
+    description: string;
+    inputs: Record<string, any>;
+    expectedOutput?: any;
+    expectedSideEffects?: string[];
+    shouldThrow?: boolean;
+}
+```
+
+### Automated Scenario Creation
+
+1. **Happy Path**: Normal execution with typical inputs
+2. **Edge Cases**: Boundary conditions, empty/null inputs, unusual but valid data
+3. **Error Scenarios**: Invalid inputs, dependency failures, exception paths
+4. **Side Effects**: Verify logging calls, file operations, state changes
+
+### Agent Pattern for Scenario Generation
+
+```typescript
+function generateTestScenarios(analysis: FunctionAnalysis): TestScenario[] {
+    const scenarios: TestScenario[] = [];
+
+    // Generate happy path for each input combination
+    scenarios.push(...generateHappyPathScenarios(analysis));
+
+    // Generate edge cases for boundary conditions
+    scenarios.push(...generateEdgeCaseScenarios(analysis));
+
+    // Generate error scenarios for each dependency
+    scenarios.push(...generateErrorScenarios(analysis));
+
+    return scenarios;
+}
+```
+
+## 🗺️ Step 3: Plan Your Test Coverage
+
+### Create a Test Coverage Matrix
+
+#### Main Flows
+
+-   ✅ **Happy path scenarios** - normal expected usage
+-   ✅ **Alternative paths** - different configuration combinations
+-   ✅ **Integration scenarios** - multiple features working together
+
+#### Edge Cases
+
+-   🔸 **Boundary conditions** - empty inputs, missing data
+-   🔸 **Error scenarios** - network failures, permission errors
+-   🔸 **Data validation** - invalid inputs, type mismatches
+
+#### Real-World Scenarios
+
+-   ✅ **Fresh install** - clean slate
+-   ✅ **Existing user** - migration scenarios
+-   ✅ **Power user** - complex configurations
+-   🔸 **Error recovery** - graceful degradation
+
+### Example Test Plan Structure
+
+```markdown
+## Test Categories
+
+### 1. Configuration Migration Tests
+
+-   No legacy settings exist
+-   Legacy settings already migrated
+-   Fresh migration needed
+-   Partial migration required
+-   Migration failures
+
+### 2. Configuration Source Tests
+
+-   Global search paths
+-   Workspace search paths
+-   Settings precedence
+-   Configuration errors
+
+### 3. Path Resolution Tests
+
+-   Absolute vs relative paths
+-   Workspace folder resolution
+-   Path validation and filtering
+
+### 4. Integration Scenarios
+
+-   Combined configurations
+-   Deduplication logic
+-   Error handling flows
+```
+
+## 🔧 Step 4: Set Up Your Test Infrastructure
+
+### Test File Structure
+
+```typescript
+// 1. Imports - group logically
+import assert from 'node:assert';
+import * as sinon from 'sinon';
+import { Uri } from 'vscode';
+import * as logging from '../../../common/logging';
+import * as pathUtils from '../../../common/utils/pathUtils';
+import * as workspaceApis from '../../../common/workspace.apis';
+
+// 2. Function under test
+import { getAllExtraSearchPaths } from '../../../managers/common/nativePythonFinder';
+
+// 3. Mock interfaces
+interface MockWorkspaceConfig {
+    get: sinon.SinonStub;
+    inspect: sinon.SinonStub;
+    update: sinon.SinonStub;
+}
+```
+
+### Mock Setup Strategy
+
+Create minimal mock objects with only required methods and use TypeScript type assertions (e.g., `mockApi as PythonEnvironmentApi`) to satisfy interface requirements instead of implementing all interface methods when only specific methods are needed for the test. Simplify mock setup by only mocking methods actually used in tests and use `as unknown as Type` for TypeScript compatibility.
+
+```typescript
+suite('Function Integration Tests', () => {
+    // 1. Declare all mocks
+    let mockGetConfiguration: sinon.SinonStub;
+    let mockGetWorkspaceFolders: sinon.SinonStub;
+    let mockTraceLog: sinon.SinonStub;
+    let mockTraceError: sinon.SinonStub;
+    let mockTraceWarn: sinon.SinonStub;
+
+    // 2. Mock complex objects
+    let pythonConfig: MockWorkspaceConfig;
+    let envConfig: MockWorkspaceConfig;
+
+    setup(() => {
+        // 3. Initialize all mocks
+        mockGetConfiguration = sinon.stub(workspaceApis, 'getConfiguration');
+        mockGetWorkspaceFolders = sinon.stub(workspaceApis, 'getWorkspaceFolders');
+        mockTraceLog = sinon.stub(logging, 'traceLog');
+        mockTraceError = sinon.stub(logging, 'traceError');
+        mockTraceWarn = sinon.stub(logging, 'traceWarn');
+
+        // 4. Set up default behaviors
+        mockGetWorkspaceFolders.returns(undefined);
+
+        // 5. Create mock configuration objects
+        // When fixing mock environment creation, use null to truly omit
+        // properties rather than undefined
+        pythonConfig = {
+            get: sinon.stub(),
+            inspect: sinon.stub(),
+            update: sinon.stub(),
+        };
+
+        envConfig = {
+            get: sinon.stub(),
+            inspect: sinon.stub(),
+            update: sinon.stub(),
+        };
+    });
+
+    teardown(() => {
+        sinon.restore(); // Always clean up!
+    });
+});
+```
+
+## Step 4: Write Tests Using Mock → Run → Assert Pattern
+
+### The Three-Phase Pattern
+
+#### Phase 1: Mock (Set up the scenario)
+
+```typescript
+test('Description of what this tests', async () => {
+    // Mock → Clear description of the scenario
+    pythonConfig.inspect.withArgs('venvPath').returns({ globalValue: '/path' });
+    envConfig.inspect.withArgs('globalSearchPaths').returns({ globalValue: [] });
+    mockGetWorkspaceFolders.returns([{ uri: Uri.file('/workspace') }]);
+```
+
+#### Phase 2: Run (Execute the function)
+
+```typescript
+// Run
+const result = await getAllExtraSearchPaths();
+```
+
+#### Phase 3: Assert (Verify the behavior)
+
+```typescript
+    // Assert - Use set-based comparison for order-agnostic testing
+    const expected = new Set(['/expected', '/paths']);
+    const actual = new Set(result);
+    assert.strictEqual(actual.size, expected.size, 'Should have correct number of paths');
+    assert.deepStrictEqual(actual, expected, 'Should contain exactly the expected paths');
+
+    // Verify side effects
+    // Use sinon.match() patterns for resilient assertions that don't break on minor output changes
+    assert(mockTraceLog.calledWith(sinon.match(/completion/i)), 'Should log completion');
+});
+```
+
+## Step 6: Make Tests Resilient
+
+### Use Order-Agnostic Comparisons
+
+```typescript
+// ❌ Brittle - depends on order
+assert.deepStrictEqual(result, ['/path1', '/path2', '/path3']);
+
+// ✅ Resilient - order doesn't matter
+const expected = new Set(['/path1', '/path2', '/path3']);
+const actual = new Set(result);
+assert.strictEqual(actual.size, expected.size, 'Should have correct number of paths');
+assert.deepStrictEqual(actual, expected, 'Should contain exactly the expected paths');
+```
+
+### Use Flexible Error Message Testing
+
+```typescript
+// ❌ Brittle - exact text matching
+assert(mockTraceError.calledWith('Error during legacy python settings migration:'));
+
+// ✅ Resilient - pattern matching
+assert(mockTraceError.calledWith(sinon.match.string, sinon.match.instanceOf(Error)), 'Should log migration error');
+
+// ✅ Resilient - key terms with regex
+assert(mockTraceError.calledWith(sinon.match(/migration.*error/i)), 'Should log migration error');
+```
+
+### Handle Complex Mock Scenarios
+
+```typescript
+// For functions that call the same mock multiple times
+envConfig.inspect.withArgs('globalSearchPaths').returns({ globalValue: [] });
+envConfig.inspect
+    .withArgs('globalSearchPaths')
+    .onSecondCall()
+    .returns({
+        globalValue: ['/migrated/paths'],
+    });
+
+// Testing async functions with child processes:
+// Call the function first to get a promise, then use setTimeout to emit mock events,
+// then await the promise - this ensures proper timing of mock setup versus function execution
+
+// Cannot stub internal function calls within the same module after import - stub external
+// dependencies instead (e.g., stub childProcessApis.spawnProcess rather than trying to stub
+// helpers.isUvInstalled when testing helpers.shouldUseUv) because intra-module calls use
+// direct references, not module exports
+```
+
+## 🧪 Step 7: Test Categories and Patterns
+
+### Configuration Tests
+
+-   Test different setting combinations
+-   Test setting precedence (workspace > user > default)
+-   Test configuration errors and recovery
+-   Always use dynamic path construction with Node.js `path` module when testing functions that resolve paths against workspace folders to ensure cross-platform compatibility
+
+### Data Flow Tests
+
+-   Test how data moves through the system
+-   Test transformations (path resolution, filtering)
+-   Test state changes (migrations, updates)
+
+### Error Handling Tests
+
+-   Test graceful degradation
+-   Test error logging
+-   Test fallback behaviors
+
+### Integration Tests
+
+-   Test multiple features together
+-   Test real-world scenarios
+-   Test edge case combinations
+
+## 📊 Step 8: Review and Refine
+
+### Test Quality Checklist
+
+-   [ ] **Clear naming** - test names describe the scenario and expected outcome
+-   [ ] **Good coverage** - main flows, edge cases, error scenarios
+-   [ ] **Resilient assertions** - won't break due to minor changes
+-   [ ] **Readable structure** - follows Mock → Run → Assert pattern
+-   [ ] **Isolated tests** - each test is independent
+-   [ ] **Fast execution** - tests run quickly with proper mocking
+
+### Common Anti-Patterns to Avoid
+
+-   ❌ Testing implementation details instead of behavior
+-   ❌ Brittle assertions that break on cosmetic changes
+-   ❌ Order-dependent tests that fail due to processing changes
+-   ❌ Tests that don't clean up mocks properly
+-   ❌ Overly complex test setup that's hard to understand
+
+## 🔄 Reviewing and Improving Existing Tests
+
+### Quick Review Process
+
+1. **Read test files** - Check structure and mock setup
+2. **Run tests** - Establish baseline functionality
+3. **Apply improvements** - Use patterns below. When reviewing existing tests, focus on behavior rather than implementation details in test names and assertions
+4. **Verify** - Ensure tests still pass
+
+### Common Fixes
+
+-   Over-complex mocks → Minimal mocks with only needed methods
+-   Brittle assertions → Behavior-focused with error messages
+-   Vague test names → Clear scenario descriptions (transform "should return X when Y" into "should [expected behavior] when [scenario context]")
+-   Missing structure → Mock → Run → Assert pattern
+-   Untestable Node.js APIs → Create proxy abstraction functions (use function overloads to preserve intelligent typing while making functions mockable)
+
+## 🧠 Agent Learnings
+
+-   When mocking `testController.createTestItem()` in unit tests, use `typemoq.It.isAny()` for parameters when testing handler behavior (not ID/label generation logic), but consider using specific matchers (e.g., `It.is((id: string) => id.startsWith('_error_'))`) when the actual values being passed are important for correctness - this balances test precision with maintainability (2)
+-   Remove unused variables from test code immediately - leftover tracking variables like `validationCallCount` that aren't referenced indicate dead code that should be simplified (1)
+-   Use `Uri.file(path).fsPath` for both sides of path comparisons in tests to ensure cross-platform compatibility - Windows converts forward slashes to backslashes automatically (1)
+-   When tests fail with "Cannot stub non-existent property", the method likely moved to a different class during refactoring - find the class that owns the method and test that class directly instead of stubbing on the original class (1)
diff --git a/.github/instructions/testing_feature_area.instructions.md b/.github/instructions/testing_feature_area.instructions.md
new file mode 100644
index 000000000000..a4e11523d7c8
--- /dev/null
+++ b/.github/instructions/testing_feature_area.instructions.md
@@ -0,0 +1,263 @@
+---
+applyTo: 'src/client/testing/**'
+---
+
+# Testing feature area — Discovery, Run, Debug, and Results
+
+This document maps the testing support in the extension: discovery, execution (run), debugging, result reporting and how those pieces connect to the codebase. It's written for contributors and agents who need to navigate, modify, or extend test support (both `unittest` and `pytest`).
+
+## Overview
+
+-   Purpose: expose Python tests in the VS Code Test Explorer (TestController), support discovery, run, debug, and surface rich results and outputs.
+-   Scope: provider-agnostic orchestration + provider-specific adapters, TestController mapping, IPC with Python-side scripts, debug launch integration, and configuration management.
+
+## High-level architecture
+
+-   Controller / UI bridge: orchestrates TestController requests and routes them to workspace adapters.
+-   Workspace adapter: provider-agnostic coordinator that translates TestController requests to provider adapters and maps payloads back into TestItems/TestRuns.
+-   Provider adapters: implement discovery/run/debug for `unittest` and `pytest` by launching Python scripts and wiring named-pipe IPC.
+-   Result resolver: translates Python-side JSON/IPCPayloads into TestController updates (start/pass/fail/output/attachments).
+-   Debug launcher: prepares debug sessions and coordinates the debugger attach flow with the Python runner.
+
+## Key components (files and responsibilities)
+
+-   Entrypoints
+    -   `src/client/testing/testController/controller.ts` — `PythonTestController` (main orchestrator).
+    -   `src/client/testing/serviceRegistry.ts` — DI/wiring for testing services.
+-   Workspace orchestration
+    -   `src/client/testing/testController/workspaceTestAdapter.ts` — `WorkspaceTestAdapter` (provider-agnostic entry used by controller).
+-   **Project-based testing (multi-project workspaces)**
+    -   `src/client/testing/testController/common/testProjectRegistry.ts` — `TestProjectRegistry` (manages project lifecycle, discovery, and nested project handling).
+    -   `src/client/testing/testController/common/projectAdapter.ts` — `ProjectAdapter` interface (represents a single Python project with its own test infrastructure).
+    -   `src/client/testing/testController/common/projectUtils.ts` — utilities for project ID generation, display names, and shared adapter creation.
+-   Provider adapters
+    -   Unittest
+        -   `src/client/testing/testController/unittest/testDiscoveryAdapter.ts`
+        -   `src/client/testing/testController/unittest/testExecutionAdapter.ts`
+    -   Pytest
+        -   `src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts`
+        -   `src/client/testing/testController/pytest/pytestExecutionAdapter.ts`
+-   Result resolution and helpers
+    -   `src/client/testing/testController/common/resultResolver.ts` — `PythonResultResolver` (maps payload -> TestController updates).
+    -   `src/client/testing/testController/common/testItemUtilities.ts` — helpers for TestItem lifecycle.
+    -   `src/client/testing/testController/common/types.ts` — `ITestDiscoveryAdapter`, `ITestExecutionAdapter`, `ITestResultResolver`, `ITestDebugLauncher`.
+    -   `src/client/testing/testController/common/debugLauncher.ts` — debug session creation helper.
+    -   `src/client/testing/testController/common/utils.ts` — named-pipe helpers and command builders (`startDiscoveryNamedPipe`, etc.).
+-   Configuration
+    -   `src/client/testing/common/testConfigurationManager.ts` — per-workspace test settings.
+    -   `src/client/testing/configurationFactory.ts` — configuration service factory.
+-   Utilities & glue
+    -   `src/client/testing/utils.ts` — assorted helpers used by adapters.
+    -   Python-side scripts: `python_files/unittestadapter/*`, `python_files/pytestadapter/*` — discovery/run code executed by adapters.
+
+## Python subprocess runners (what runs inside Python)
+
+The adapters in the extension don't implement test discovery/run logic themselves — they spawn a Python subprocess that runs small helper scripts located under `python_files/` and stream structured events back to the extension over the named-pipe IPC. This is a central part of the feature area; changes here usually require coordinated edits in both the TypeScript adapters and the Python scripts.
+
+-   Unittest helpers (folder: `python_files/unittestadapter`)
+
+    -   `discovery.py` — performs `unittest` discovery and emits discovery payloads (test suites, cases, locations) on the IPC channel.
+    -   `execution.py` / `django_test_runner.py` — run tests for `unittest` and, where applicable, Django test runners; emit run events (start, stdout/stderr, pass, fail, skip, teardown) and attachment info.
+    -   `pvsc_utils.py`, `django_handler.py` — utility helpers used by the runners for environment handling and Django-specific wiring.
+    -   The adapter TypeScript files (`testDiscoveryAdapter.ts`, `testExecutionAdapter.ts`) construct the command line, start a named-pipe listener, and spawn these Python scripts using the extension's ExecutionFactory (activated interpreter) so the scripts execute inside the user's selected environment.
+
+-   Pytest helpers (folder: `python_files/vscode_pytest`)
+
+    -   `_common.py` — shared helpers for pytest runner scripts.
+    -   `run_pytest_script.py` — the primary pytest runner used for discovery and execution; emits the same structured IPC payloads the extension expects (discovery events and run events).
+    -   The `pytest` execution adapter (`pytestExecutionAdapter.ts`) and discovery adapter build the CLI to run `run_pytest_script.py`, start the pipe, and translate incoming payloads via `PythonResultResolver`.
+
+-   IPC contract and expectations
+
+    -   Adapters rely on a stable JSON payload contract emitted by the Python scripts: identifiers for tests, event types (discovered, collected, started, passed, failed, skipped), timings, error traces, and optional attachments (logs, captured stdout/stderr, file links).
+    -   The extension maps these payloads to `TestItem`/`TestRun` updates via `PythonResultResolver` (`src/client/testing/testController/common/resultResolver.ts`). If you change payload shape, update the resolver and tests concurrently.
+
+-   How the subprocess is started
+    -   Execution adapters use the extension's `ExecutionFactory` (preferred) to get an activated interpreter and then spawn a child process that runs the helper script. The adapter will set up environment variables and command-line args (including the pipe name / run-id) so the Python runner knows where to send events and how to behave (discovery vs run vs debug).
+    -   For debug sessions a debug-specific entry argument/port is passed and `common/debugLauncher.ts` coordinates starting a VS Code debug session that will attach to the Python process.
+
+## Core functionality (what to change where)
+
+-   Discovery
+    -   Entry: `WorkspaceTestAdapter.discoverTests` → provider discovery adapter. Adapter starts a named-pipe listener, spawns the discovery script in an activated interpreter, forwards discovery events to `PythonResultResolver` which creates/updates TestItems.
+    -   Files: `workspaceTestAdapter.ts`, `*DiscoveryAdapter.ts`, `resultResolver.ts`, `testItemUtilities.ts`.
+-   Run / Execution
+    -   Entry: `WorkspaceTestAdapter.executeTests` → provider execution adapter. Adapter spawns runner in an activated env, runner streams run events to the pipe, `PythonResultResolver` updates a `TestRun` with start/pass/fail and attachments.
+    -   Files: `workspaceTestAdapter.ts`, `*ExecutionAdapter.ts`, `resultResolver.ts`.
+-   Debugging
+    -   Flow: debug request flows like a run but goes through `debugLauncher.ts` to create a VS Code debug session with prepared ports/pipes. The Python runner coordinates attach/continue with the debugger.
+    -   Files: `*ExecutionAdapter.ts`, `common/debugLauncher.ts`, `common/types.ts`.
+-   Result reporting
+    -   `resultResolver.ts` is the canonical place to change how JSON payloads map to TestController constructs (messages, durations, error traces, attachments).
+
+## Typical workflows (short)
+
+-   Full discovery
+
+    1. `PythonTestController` triggers discovery -> `WorkspaceTestAdapter.discoverTests`.
+    2. Provider discovery adapter starts pipe and launches Python discovery script.
+    3. Discovery events -> `PythonResultResolver` -> TestController tree updated.
+
+-   Run tests
+
+    1. Controller collects TestItems -> creates `TestRun`.
+    2. `WorkspaceTestAdapter.executeTests` delegates to execution adapter which launches the runner.
+    3. Runner events arrive via pipe -> `PythonResultResolver` updates `TestRun`.
+    4. On process exit the run is finalized.
+
+-   Debug a test
+    1. Debug request flows to execution adapter.
+    2. Adapter prepares ports and calls `debugLauncher` to start a VS Code debug session with the run ID.
+    3. Runner coordinates with the debugger; `PythonResultResolver` still receives and applies run events.
+
+## Tests and examples to inspect
+
+-   Unit/integration tests for adapters and orchestration under `src/test/` (examples):
+    -   `src/test/testing/common/testingAdapter.test.ts`
+    -   `src/test/testing/testController/workspaceTestAdapter.unit.test.ts`
+    -   `src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts`
+    -   Adapter tests demonstrate expected telemetry, debug-launch payloads and result resolution.
+
+## History & evolution (brief)
+
+-   Migration to TestController API: the code organizes around VS Code TestController, mapping legacy adapter behaviour into TestItems/TestRuns.
+-   Named-pipe IPC: discovery/run use named-pipe IPC to stream events from Python runner scripts (`python_files/*`) which enables richer, incremental updates and debug coordination.
+-   Environment activation: adapters prefer the extension ExecutionFactory (activated interpreter) to run discovery and test scripts.
+
+## Pointers for contributors (practical)
+
+-   To extend discovery output: update the Python discovery script in `python_files/*` and `resultResolver.ts` to parse new payload fields.
+-   To change run behaviour (args/env/timouts): update the provider execution adapter (`*ExecutionAdapter.ts`) and add/update tests under `src/test/`.
+-   To change debug flow: edit `common/debugLauncher.ts` and adapters' debug paths; update tests that assert launch argument shapes.
+
+## Django support (how it works)
+
+-   The extension supports Django projects by delegating discovery and execution to Django-aware Python helpers under `python_files/unittestadapter`.
+    -   `python_files/unittestadapter/django_handler.py` contains helpers that invoke `manage.py` for discovery or execute Django test runners inside the project context.
+    -   `python_files/unittestadapter/django_test_runner.py` provides `CustomDiscoveryTestRunner` and `CustomExecutionTestRunner` which integrate with the extension by using the same IPC contract (they use `UnittestTestResult` and `send_post_request` to emit discovery/run payloads).
+-   How adapters pass Django configuration:
+    -   Execution adapters set environment variables (e.g. `MANAGE_PY_PATH`) and modify `PYTHONPATH` so Django code and the custom test runner are importable inside the spawned subprocess.
+    -   For discovery the adapter may run the discovery helper which calls `manage.py test` with a custom test runner that emits discovery payloads instead of executing tests.
+-   Practical notes for contributors:
+    -   Changes to Django discovery/execution often require edits in both `django_test_runner.py`/`django_handler.py` and the TypeScript adapters (`testDiscoveryAdapter.ts` / `testExecutionAdapter.ts`).
+    -   The Django test runner expects `TEST_RUN_PIPE` environment variable to be present to send IPC events (see `django_test_runner.py`).
+
+## Settings referenced by this feature area
+
+-   The extension exposes several `python.testing.*` settings used by adapters and configuration code (declared in `package.json`):
+    -   `python.testing.pytestEnabled`, `python.testing.unittestEnabled` — enable/disable frameworks.
+    -   `python.testing.pytestPath`, `python.testing.pytestArgs`, `python.testing.unittestArgs` — command path and CLI arguments used when spawning helper scripts.
+    -   `python.testing.cwd` — optional working directory used when running discovery/runs.
+    -   `python.testing.autoTestDiscoverOnSaveEnabled`, `python.testing.autoTestDiscoverOnSavePattern` — control automatic discovery on save.
+    -   `python.testing.debugPort` — default port used for debug runs.
+    -   `python.testing.promptToConfigure` — whether to prompt users to configure tests when potential test folders are found.
+-   Where to look in the code:
+    -   Settings are consumed by `src/client/testing/common/testConfigurationManager.ts`, `src/client/testing/configurationFactory.ts`, and adapters under `src/client/testing/testController/*` which read settings to build CLI args and env for subprocesses.
+    -   The setting definitions and descriptions are in `package.json` and localized strings in `package.nls.json`.
+
+## Project-based testing (multi-project workspaces)
+
+Project-based testing enables multi-project workspace support where each Python project gets its own test tree root with its own Python environment.
+
+### Architecture
+
+-   **TestProjectRegistry** (`testProjectRegistry.ts`): Central registry that:
+
+    -   Discovers Python projects via the Python Environments API
+    -   Creates and manages `ProjectAdapter` instances per workspace
+    -   Computes nested project relationships and configures ignore lists
+    -   Falls back to "legacy" single-adapter mode when API unavailable
+
+-   **ProjectAdapter** (`projectAdapter.ts`): Interface representing a single project with:
+    -   Project identity (ID, name, URI from Python Environments API)
+    -   Python environment with execution details
+    -   Test framework adapters (discovery/execution)
+    -   Nested project ignore paths (for parent projects)
+
+### How it works
+
+1. **Activation**: When the extension activates, `PythonTestController` checks if the Python Environments API is available.
+2. **Project discovery**: `TestProjectRegistry.discoverAndRegisterProjects()` queries the API for all Python projects in each workspace.
+3. **Nested handling**: `configureNestedProjectIgnores()` identifies child projects and adds their paths to parent projects' ignore lists.
+4. **Test discovery**: For each project, the controller calls `project.discoveryAdapter.discoverTests()` with the project's URI. The adapter sets `PROJECT_ROOT_PATH` environment variable for the Python runner.
+5. **Python side**:
+    - For pytest: `get_test_root_path()` in `vscode_pytest/__init__.py` returns `PROJECT_ROOT_PATH` (if set) or falls back to `cwd`.
+    - For unittest: `discovery.py` uses `PROJECT_ROOT_PATH` as `top_level_dir` and `project_root_path` to root the test tree at the project directory.
+6. **Test tree**: Each project gets its own root node in the Test Explorer, with test IDs scoped by project ID using the `@@vsc@@` separator (defined in `projectUtils.ts`).
+
+### Nested project handling: pytest vs unittest
+
+**pytest** supports the `--ignore` flag to exclude paths during test collection. When nested projects are detected, parent projects automatically receive `--ignore` flags for child project paths. This ensures each test appears under exactly one project in the test tree.
+
+**unittest** does not support path exclusion during `discover()`. Therefore, tests in nested project directories may appear under multiple project roots (both the parent and the child project). This is **expected behavior** for unittest:
+
+-   Each project discovers and displays all tests it finds within its directory structure
+-   There is no deduplication or collision detection
+-   Users may see the same test file under multiple project roots if their project structure has nesting
+
+This approach was chosen because:
+
+1. unittest's `TestLoader.discover()` has no built-in path exclusion mechanism
+2. Implementing custom exclusion would add significant complexity with minimal benefit
+3. The existing approach is transparent and predictable - each project shows what it finds
+
+### Empty projects and root nodes
+
+If a project discovers zero tests, its root node will still appear in the Test Explorer as an empty folder. This ensures consistent behavior and makes it clear which projects were discovered, even if they have no tests yet.
+
+### Logging prefix
+
+All project-based testing logs use the `[test-by-project]` prefix for easy filtering in the output channel.
+
+### Key files
+
+-   Python side:
+    -   `python_files/vscode_pytest/__init__.py` — `get_test_root_path()` function and `PROJECT_ROOT_PATH` environment variable for pytest.
+    -   `python_files/unittestadapter/discovery.py` — `discover_tests()` with `project_root_path` parameter and `PROJECT_ROOT_PATH` handling for unittest discovery.
+    -   `python_files/unittestadapter/execution.py` — `run_tests()` with `project_root_path` parameter and `PROJECT_ROOT_PATH` handling for unittest execution.
+-   TypeScript: `testProjectRegistry.ts`, `projectAdapter.ts`, `projectUtils.ts`, and the discovery/execution adapters.
+
+### Tests
+
+-   `src/test/testing/testController/common/testProjectRegistry.unit.test.ts` — TestProjectRegistry tests
+-   `src/test/testing/testController/common/projectUtils.unit.test.ts` — Project utility function tests
+-   `python_files/tests/pytestadapter/test_discovery.py` — pytest PROJECT_ROOT_PATH tests (see `test_project_root_path_env_var()` and `test_symlink_with_project_root_path()`)
+-   `python_files/tests/unittestadapter/test_discovery.py` — unittest `project_root_path` / PROJECT_ROOT_PATH discovery tests
+-   `python_files/tests/unittestadapter/test_execution.py` — unittest `project_root_path` / PROJECT_ROOT_PATH execution tests
+-   `src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts` — unittest discovery adapter PROJECT_ROOT_PATH tests
+-   `src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts` — unittest execution adapter PROJECT_ROOT_PATH tests
+
+## Coverage support (how it works)
+
+-   Coverage is supported by running the Python helper scripts with coverage enabled and then collecting a coverage payload from the runner.
+    -   Pytest-side coverage logic lives in `python_files/vscode_pytest/__init__.py` (checks `COVERAGE_ENABLED`, imports `coverage`, computes per-file metrics and emits a `CoveragePayloadDict`).
+    -   Unittest adapters enable coverage by setting environment variable(s) (e.g. `COVERAGE_ENABLED`) when launching the subprocess; adapters and `resultResolver.ts` handle the coverage profile kind (`TestRunProfileKind.Coverage`).
+-   Flow summary:
+    1. User starts a Coverage run via Test Explorer (profile kind `Coverage`).
+    2. Controller/adapters set `COVERAGE_ENABLED` (or equivalent) in the subprocess env and invoke the runner script.
+    3. The Python runner collects coverage (using `coverage` or `pytest-cov`), builds a file-level coverage map, and sends a coverage payload back over the IPC.
+    4. `PythonResultResolver` (`src/client/testing/testController/common/resultResolver.ts`) receives the coverage payload and stores `detailedCoverageMap` used by the TestController profile to show file-level coverage details.
+-   Tests that exercise coverage flows are under `src/test/testing/*` and `python_files/tests/*` (see `testingAdapter.test.ts` and adapter unit tests that assert `COVERAGE_ENABLED` is set appropriately).
+
+## Interaction with the VS Code API
+
+-   TestController API
+    -   The feature area is built on VS Code's TestController/TestItem/TestRun APIs (`vscode.tests.createTestController` / `tests.createTestController` in the code). The controller creates a `TestController` in `src/client/testing/testController/controller.ts` and synchronizes `TestItem` trees with discovery payloads.
+    -   `PythonResultResolver` maps incoming JSON events to VS Code API calls: `testRun.appendOutput`, `testRun.passed/failed/skipped`, `testRun.end`, and `TestItem` updates (labels, locations, children).
+-   Debug API
+    -   Debug runs use the Debug API to start an attach/launch session. The debug launcher implementation is in `src/client/testing/testController/common/debugLauncher.ts` which constructs a debug configuration and calls the VS Code debug API to start a session (e.g. `vscode.debug.startDebugging`).
+    -   Debug adapter/resolver code in the extension's debugger modules may also be used when attaching to Django or test subprocesses.
+-   Commands and configuration
+    -   The Test Controller wires commands that appear in the Test Explorer and editor context menus (see `package.json` contributes `commands`) and listens to configuration changes filtered by `python.testing` in `src/client/testing/main.ts`.
+-   The "Copy Test ID" command (`python.copyTestId`) can be accessed from both the Test Explorer context menu (`testing/item/context`) and the editor gutter icon context menu (`testing/item/gutter`). This command copies test identifiers to the clipboard in the appropriate format for the active test framework (pytest path format or unittest module.class.method format).
+-   Execution factory & activated environments
+    -   Adapters use the extension `ExecutionFactory` to spawn subprocesses in an activated interpreter (so the user's venv/conda is used). This involves the extension's internal environment execution APIs and sometimes `envExt` helpers when the external environment extension is present.
+
+## Learnings
+
+-   Never await `showErrorMessage()` calls in test execution adapters as it blocks the test UI thread and freezes the Test Explorer (1)
+-   VS Code test-related context menus are contributed to using both `testing/item/context` and `testing/item/gutter` menu locations in package.json for full coverage (1)
+
+```
+
+```
diff --git a/.github/prompts/extract-impl-instructions.prompt.md b/.github/prompts/extract-impl-instructions.prompt.md
new file mode 100644
index 000000000000..c2fb08b443c7
--- /dev/null
+++ b/.github/prompts/extract-impl-instructions.prompt.md
@@ -0,0 +1,79 @@
+---
+mode: edit
+---
+
+Analyze the specified part of the VS Code Python Extension codebase to generate or update implementation instructions in `.github/instructions/<component>.instructions.md`.
+
+## Task
+
+Create concise developer guidance focused on:
+
+### Implementation Essentials
+
+-   **Core patterns**: How this component is typically implemented and extended
+-   **Key interfaces**: Essential classes, services, and APIs with usage examples
+-   **Integration points**: How this component interacts with other extension parts
+-   **Common tasks**: Typical development scenarios with step-by-step guidance
+
+### Content Structure
+
+````markdown
+---
+description: 'Implementation guide for the <component> part of the Python Extension'
+---
+
+# <Component> Implementation Guide
+
+## Overview
+
+Brief description of the component's purpose and role in VS Code Python Extension.
+
+## Key Concepts
+
+-   Main abstractions and their responsibilities
+-   Important interfaces and base classes
+
+## Common Implementation Patterns
+
+### Pattern 1: [Specific Use Case]
+
+```typescript
+// Code example showing typical implementation
+```
+````
+
+### Pattern 2: [Another Use Case]
+
+```typescript
+// Another practical example
+```
+
+## Integration Points
+
+-   How this component connects to other VS Code Python Extension systems
+-   Required services and dependencies
+-   Extension points and contribution models
+
+## Essential APIs
+
+-   Key methods and interfaces developers need
+-   Common parameters and return types
+
+## Gotchas and Best Practices
+
+-   Non-obvious behaviors to watch for
+-   Performance considerations
+-   Common mistakes to avoid
+
+```
+
+## Guidelines
+- **Be specific**: Use actual class names, method signatures, and file paths
+- **Show examples**: Include working code snippets from the codebase
+- **Target implementation**: Focus on how to build with/extend this component
+- **Keep it actionable**: Every section should help developers accomplish tasks
+
+Source conventions from existing `.github/instructions/*.instructions.md`, `CONTRIBUTING.md`, and codebase patterns.
+
+If `.github/instructions/<component>.instructions.md` exists, intelligently merge new insights with existing content.
+```
diff --git a/.github/prompts/extract-usage-instructions.prompt.md b/.github/prompts/extract-usage-instructions.prompt.md
new file mode 100644
index 000000000000..ea48f162a220
--- /dev/null
+++ b/.github/prompts/extract-usage-instructions.prompt.md
@@ -0,0 +1,30 @@
+---
+mode: edit
+---
+
+Analyze the user requested part of the codebase (use a suitable <placeholder>) to generate or update `.github/instructions/<placeholder>.instructions.md` for guiding developers and AI coding agents.
+
+Focus on practical usage patterns and essential knowledge:
+
+-   How to use, extend, or integrate with this code area
+-   Key architectural patterns and conventions specific to this area
+-   Common implementation patterns with code examples
+-   Integration points and typical interaction patterns with other components
+-   Essential gotchas and non-obvious behaviors
+
+Source existing conventions from `.github/instructions/*.instructions.md`, `CONTRIBUTING.md`, and `README.md`.
+
+Guidelines:
+
+-   Write concise, actionable instructions using markdown structure
+-   Document discoverable patterns with concrete examples
+-   If `.github/instructions/<placeholder>.instructions.md` exists, merge intelligently
+-   Target developers who need to work with or extend this code area
+
+Update `.github/instructions/<placeholder>.instructions.md` with header:
+
+```
+---
+description: "How to work with the <placeholder> part of the codebase"
+---
+```
diff --git a/.github/release_plan.md b/.github/release_plan.md
index bc9e623bc774..091ed559825b 100644
--- a/.github/release_plan.md
+++ b/.github/release_plan.md
@@ -40,7 +40,7 @@ NOTE: the number of this release is in the issue title and can be substituted in
 -   [ ] Update `pet`:
     -  [ ] Go to the [pet](https://github.com/microsoft/python-environment-tools) repo and check `main` and latest `release/*` branch. If there are new changes in `main` then create a branch called `release/YYYY.minor` (matching python extension release `major.minor`).
     -  [ ] Update `build\azure-pipeline.stable.yml` to point to the latest `release/YYYY.minor` for `python-environment-tools`.
--   [ ] Change the version in `package.json` to the next **even** number and switch the `-dev` to `-rc`. (🤖)
+-   [ ] Change the version in `package.json` to the next **even** number. (🤖)
 -   [ ] Run `npm install` to make sure `package-lock.json` is up-to-date _(you should now see changes to the `package.json` and `package-lock.json` at this point which update the version number **only**)_. (🤖)
 -   [ ] Update `ThirdPartyNotices-Repository.txt` as appropriate. You can check by looking at the [commit history](https://github.com/microsoft/vscode-python/commits/main) and scrolling through to see if there's anything listed there which might have pulled in some code directly into the repository from somewhere else. If you are still unsure you can check with the team.
 -   [ ] Create a PR from your branch  **`bump-release-[YYYY.minor]`** to `main`. Add the `"no change-log"` tag to the PR so it does not show up on the release notes before merging it.
@@ -64,7 +64,7 @@ NOTE: If there are release branches that are two versions old you can delete the
 ### Step 4: Return `main` to dev and unfreeze (❄️ ➡ 💧)
 NOTE: The purpose of this step is ensuring that main always is on a dev version number for every night's 🌃 pre-release. Therefore it is imperative that you do this directly after the previous steps to reset the version in main to a dev version **before** a pre-release goes out.
 -   [ ] Create a branch called **`bump-dev-version-YYYY.[minor+1]`**.
--   [ ] Bump the minor version number in the `package.json` to the next `YYYY.[minor+1]` which will be an odd number, and switch the `-rc` to `-dev`.(🤖)
+-   [ ] Bump the minor version number in the `package.json` to the next `YYYY.[minor+1]` which will be an odd number, and add `-dev`.(🤖)
 -   [ ] Run `npm install` to make sure `package-lock.json` is up-to-date _(you should now see changes to the `package.json` and `package-lock.json` only relating to the new version number)_ . (🤖)
 -   [ ] Create a PR from this branch against `main` and merge it.
 
@@ -83,12 +83,6 @@ NOTE: this PR should make all CI relating to `main` be passing again (such as th
 ### Step 6: Take the release branch from a candidate to the finalized release
 -   [ ] Make sure the [appropriate pull requests](https://github.com/microsoft/vscode-docs/pulls) for the [documentation](https://code.visualstudio.com/docs/python/python-tutorial) -- including the [WOW](https://code.visualstudio.com/docs/languages/python) page -- are ready.
 -   [ ] Check to make sure any final updates to the **`release/YYYY.minor`** branch have been merged.
--   [ ] Create a branch against  **`release/YYYY.minor`** called **`finalized-release-[YYYY.minor]`**.
--   [ ] Update the version in `package.json` to remove the `-rc` (🤖) from the version.
--   [ ] Run `npm install` to make sure `package-lock.json` is up-to-date _(the only update should be the version number if `package-lock.json` has been kept up-to-date)_. (🤖)
--   [ ] Update `ThirdPartyNotices-Repository.txt` manually if necessary.
--   [ ] Create a PR from **`finalized-release-[YYYY.minor]`** against `release/YYYY.minor` and merge it.
-
 
 ### Step 7: Execute the Release
 -   [ ] Make sure CI is passing for **`release/YYYY.minor`** release branch (🤖).
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 53ee0f003668..09d019dec4a7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,8 +8,10 @@ on:
       - 'release/*'
       - 'release-*'
 
+permissions: {}
+
 env:
-  NODE_VERSION: 20.18.0
+  NODE_VERSION: 22.21.1
   PYTHON_VERSION: '3.10' # YML treats 3.10 the number as 3.1, so quotes around 3.10
   # Force a path with spaces and to test extension works in these scenarios
   # Unicode characters are causing 2.7 failures so skip that for now.
@@ -82,13 +84,16 @@ jobs:
           #     vsix-target: alpine-arm64
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: 'python-env-tools'
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -110,7 +115,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Lint
         uses: ./.github/actions/lint
@@ -123,20 +130,22 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Use Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Install core Python requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           options: '-t ./python_files/lib/python --no-cache-dir --implementation py'
 
       - name: Install Jedi requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           requirements-file: './python_files/jedilsp_requirements/requirements.txt'
           options: '-t ./python_files/lib/jedilsp --no-cache-dir --implementation py'
@@ -146,7 +155,7 @@ jobs:
           python -m pip install --upgrade -r build/test-requirements.txt
 
       - name: Run Pyright
-        uses: jakebailey/pyright-action@v2
+        uses: jakebailey/pyright-action@8ec14b5cfe41f26e5f41686a31eb6012758217ef # v3.0.2
         with:
           version: 1.1.308
           working-directory: 'python_files'
@@ -165,21 +174,22 @@ jobs:
         # macOS runners are expensive, and we assume that Ubuntu is enough to cover the Unix case.
         os: [ubuntu-latest, windows-latest]
         # Run the tests on the oldest and most recent versions of Python.
-        python: ['3.8', '3.x', '3.13-dev']
+        python: ['3.10', '3.x', '3.13']
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           path: ${{ env.special-working-directory-relative }}
+          persist-credentials: false
 
       - name: Use Python ${{ matrix.python }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python }}
 
       - name: Install base Python requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           requirements-file: '"${{ env.special-working-directory-relative }}/requirements.txt"'
           options: '-t "${{ env.special-working-directory-relative }}/python_files/lib/python" --no-cache-dir --implementation py'
@@ -208,15 +218,17 @@ jobs:
         test-suite: [ts-unit, venv, single-workspace, multi-workspace, debugger, functional]
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           path: ${{ env.special-working-directory-relative }}
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: ${{ env.special-working-directory-relative }}/python-env-tools
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -224,7 +236,7 @@ jobs:
           sparse-checkout-cone-mode: false
 
       - name: Install Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: ${{ env.NODE_VERSION }}
           cache: 'npm'
@@ -240,7 +252,7 @@ jobs:
         run: npx @vscode/l10n-dev@latest export ./src
 
       - name: Install Python ${{ matrix.python }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python }}
 
@@ -358,7 +370,7 @@ jobs:
         env:
           TEST_FILES_SUFFIX: testvirtualenvs
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testSingleWorkspace
           working-directory: ${{ env.special-working-directory }}
@@ -367,7 +379,7 @@ jobs:
       - name: Run single-workspace tests
         env:
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testSingleWorkspace
           working-directory: ${{ env.special-working-directory }}
@@ -376,7 +388,7 @@ jobs:
       - name: Run multi-workspace tests
         env:
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testMultiWorkspace
           working-directory: ${{ env.special-working-directory }}
@@ -385,7 +397,7 @@ jobs:
       - name: Run debugger tests
         env:
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testDebugger
           working-directory: ${{ env.special-working-directory }}
@@ -414,13 +426,16 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: ${{ env.special-working-directory-relative }}/python-env-tools
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index d902a68878e0..5528fbbe9c0a 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,11 +36,13 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v4
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -65,4 +67,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v4
diff --git a/.github/workflows/community-feedback-auto-comment.yml b/.github/workflows/community-feedback-auto-comment.yml
index cf3c4f51fe61..27f93400a023 100644
--- a/.github/workflows/community-feedback-auto-comment.yml
+++ b/.github/workflows/community-feedback-auto-comment.yml
@@ -12,7 +12,7 @@ jobs:
       issues: write
     steps:
       - name: Check For Existing Comment
-        uses: peter-evans/find-comment@v3
+        uses: peter-evans/find-comment@b30e6a3c0ed37e7c023ccd3f1db5c6c0b0c23aad # v4.0.0
         id: finder
         with:
           issue-number: ${{ github.event.issue.number }}
@@ -21,7 +21,7 @@ jobs:
 
       - name: Add Community Feedback Comment
         if: steps.finder.outputs.comment-id == ''
-        uses: peter-evans/create-or-update-comment@v4
+        uses: peter-evans/create-or-update-comment@e8674b075228eee787fea43ef493e45ece1004c9 # v5.0.0
         with:
           issue-number: ${{ github.event.issue.number }}
           body: |
diff --git a/.github/workflows/gen-issue-velocity.yml b/.github/workflows/gen-issue-velocity.yml
index a2fd9610892d..41d79e4074d0 100644
--- a/.github/workflows/gen-issue-velocity.yml
+++ b/.github/workflows/gen-issue-velocity.yml
@@ -5,16 +5,21 @@ on:
     - cron: '0 0 * * 2' # Runs every Tuesday at midnight
   workflow_dispatch:
 
+permissions:
+  issues: read
+
 jobs:
   generate-summary:
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.x'
 
diff --git a/.github/workflows/info-needed-closer.yml b/.github/workflows/info-needed-closer.yml
index 64a96b06e556..46892a58e800 100644
--- a/.github/workflows/info-needed-closer.yml
+++ b/.github/workflows/info-needed-closer.yml
@@ -14,10 +14,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Actions
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/vscode-github-triage-actions'
           path: ./actions
+          persist-credentials: false
           ref: stable
       - name: Install Actions
         run: npm install --production --prefix ./actions
diff --git a/.github/workflows/issue-labels.yml b/.github/workflows/issue-labels.yml
index fbd92d9edd01..dcbd114086e2 100644
--- a/.github/workflows/issue-labels.yml
+++ b/.github/workflows/issue-labels.yml
@@ -17,11 +17,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Actions
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/vscode-github-triage-actions'
           ref: stable
           path: ./actions
+          persist-credentials: false
 
       - name: Install Actions
         run: npm install --production --prefix ./actions
diff --git a/.github/workflows/lock-issues.yml b/.github/workflows/lock-issues.yml
index 47f243d71979..544d04ee185e 100644
--- a/.github/workflows/lock-issues.yml
+++ b/.github/workflows/lock-issues.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 'Lock Issues'
-        uses: dessant/lock-threads@v5
+        uses: dessant/lock-threads@7266a7ce5c1df01b1c6db85bf8cd86c737dadbe7 # v6.0.0
         with:
           github-token: ${{ github.token }}
           issue-inactive-days: '30'
diff --git a/.github/workflows/pr-check.yml b/.github/workflows/pr-check.yml
index b6bdaa8e250b..c8a6f2dd416e 100644
--- a/.github/workflows/pr-check.yml
+++ b/.github/workflows/pr-check.yml
@@ -7,8 +7,10 @@ on:
       - main
       - release*
 
+permissions: {}
+
 env:
-  NODE_VERSION: 20.18.0
+  NODE_VERSION: 22.21.1
   PYTHON_VERSION: '3.10' # YML treats 3.10 the number as 3.1, so quotes around 3.10
   MOCHA_REPORTER_JUNIT: true # Use the mocha-multi-reporters and send output to both console (spec) and JUnit (mocha-junit-reporter). Also enables a reporter which exits the process running the tests if it haven't already.
   ARTIFACT_NAME_VSIX: ms-python-insiders-vsix
@@ -55,13 +57,16 @@ jobs:
           #     vsix-target: alpine-arm64
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: 'python-env-tools'
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -82,7 +87,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Lint
         uses: ./.github/actions/lint
@@ -94,18 +101,21 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Use Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: 'python-env-tools'
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -113,12 +123,12 @@ jobs:
           sparse-checkout-cone-mode: false
 
       - name: Install base Python requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           options: '-t ./python_files/lib/python --no-cache-dir --implementation py'
 
       - name: Install Jedi requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           requirements-file: './python_files/jedilsp_requirements/requirements.txt'
           options: '-t ./python_files/lib/jedilsp --no-cache-dir --implementation py'
@@ -128,7 +138,7 @@ jobs:
           python -m pip install --upgrade -r build/test-requirements.txt
 
       - name: Run Pyright
-        uses: jakebailey/pyright-action@v2
+        uses: jakebailey/pyright-action@8ec14b5cfe41f26e5f41686a31eb6012758217ef # v3.0.2
         with:
           version: 1.1.308
           working-directory: 'python_files'
@@ -147,17 +157,18 @@ jobs:
         # macOS runners are expensive, and we assume that Ubuntu is enough to cover the Unix case.
         os: [ubuntu-latest, windows-latest]
         # Run the tests on the oldest and most recent versions of Python.
-        python: ['3.8', '3.x', '3.13-dev'] # run for 3 pytest versions, most recent stable, oldest version supported and pre-release
+        python: ['3.10', '3.x', '3.13'] # run for 3 pytest versions, most recent stable, oldest version supported and pre-release
         pytest-version: ['pytest', 'pytest@pre-release', 'pytest==6.2.0']
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           path: ${{ env.special-working-directory-relative }}
+          persist-credentials: false
 
       - name: Use Python ${{ matrix.python }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python }}
 
@@ -174,7 +185,7 @@ jobs:
       - name: Install specific pytest version
         run: python -m pytest --version
       - name: Install base Python requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           requirements-file: '"${{ env.special-working-directory-relative }}/requirements.txt"'
           options: '-t "${{ env.special-working-directory-relative }}/python_files/lib/python" --no-cache-dir --implementation py'
@@ -204,15 +215,17 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           path: ${{ env.special-working-directory-relative }}
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: ${{ env.special-working-directory-relative }}/python-env-tools
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -220,7 +233,7 @@ jobs:
           sparse-checkout-cone-mode: false
 
       - name: Install Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: ${{ env.NODE_VERSION }}
           cache: 'npm'
@@ -236,7 +249,7 @@ jobs:
         run: npx @vscode/l10n-dev@latest export ./src
 
       - name: Use Python ${{ matrix.python }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python }}
 
@@ -354,7 +367,7 @@ jobs:
         env:
           TEST_FILES_SUFFIX: testvirtualenvs
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testSingleWorkspace
           working-directory: ${{ env.special-working-directory }}
@@ -363,7 +376,7 @@ jobs:
       - name: Run single-workspace tests
         env:
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testSingleWorkspace
           working-directory: ${{ env.special-working-directory }}
@@ -372,7 +385,7 @@ jobs:
       - name: Run debugger tests
         env:
           CI_PYTHON_VERSION: ${{ matrix.python }}
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testDebugger
           working-directory: ${{ env.special-working-directory }}
@@ -399,15 +412,17 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           path: ${{ env.special-working-directory-relative }}
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: ${{ env.special-working-directory-relative }}/python-env-tools
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -437,13 +452,16 @@ jobs:
     steps:
       # Need the source to have the tests available.
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: python-env-tools
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -459,6 +477,8 @@ jobs:
   ### Coverage run
   coverage:
     name: Coverage
+    # TEMPORARILY DISABLED - hanging in CI, needs investigation
+    if: false
     # The value of runs-on is the OS of the current job (specified in the strategy matrix below) instead of being hardcoded.
     runs-on: ${{ matrix.os }}
     needs: [lint, check-types, python-tests, tests, native-tests]
@@ -470,13 +490,16 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Checkout Python Environment Tools
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/python-environment-tools'
           path: python-env-tools
+          persist-credentials: false
           sparse-checkout: |
             crates
             Cargo.toml
@@ -484,7 +507,7 @@ jobs:
           sparse-checkout-cone-mode: false
 
       - name: Install Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: ${{ env.NODE_VERSION }}
           cache: 'npm'
@@ -499,7 +522,7 @@ jobs:
         run: npx @vscode/l10n-dev@latest export ./src
 
       - name: Use Python ${{ env.PYTHON_VERSION }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           cache: 'pip'
@@ -510,12 +533,12 @@ jobs:
             build/functional-test-requirements.txt
 
       - name: Install base Python requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           options: '-t ./python_files/lib/python --implementation py'
 
       - name: Install Jedi requirements
-        uses: brettcannon/pip-secure-install@v1
+        uses: brettcannon/pip-secure-install@92f400e3191171c1858cc0e0d9ac6320173fdb0c # v1.0.0
         with:
           requirements-file: './python_files/jedilsp_requirements/requirements.txt'
           options: '-t ./python_files/lib/jedilsp --implementation py'
@@ -618,7 +641,7 @@ jobs:
           TEST_FILES_SUFFIX: testvirtualenvs
           CI_PYTHON_VERSION: ${{ env.PYTHON_VERSION }}
           CI_DISABLE_AUTO_SELECTION: 1
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testSingleWorkspace:cover
 
@@ -626,7 +649,7 @@ jobs:
         env:
           CI_PYTHON_VERSION: ${{ env.PYTHON_VERSION }}
           CI_DISABLE_AUTO_SELECTION: 1
-        uses: GabrielBB/xvfb-action@v1.7
+        uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
         with:
           run: npm run testSingleWorkspace:cover
 
@@ -635,7 +658,7 @@ jobs:
       #   env:
       #     CI_PYTHON_VERSION: ${{ env.PYTHON_VERSION }}
       #     CI_DISABLE_AUTO_SELECTION: 1
-      #   uses: GabrielBB/xvfb-action@v1.7
+      #   uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
       #   with:
       #     run: npm run testMultiWorkspace:cover
 
@@ -644,7 +667,7 @@ jobs:
       #   env:
       #     CI_PYTHON_VERSION: ${{ env.PYTHON_VERSION }}
       #     CI_DISABLE_AUTO_SELECTION: 1
-      #   uses: GabrielBB/xvfb-action@v1.7
+      #   uses: GabrielBB/xvfb-action@b706e4e27b14669b486812790492dc50ca16b465 # v1.7
       #   with:
       #     run: npm run testDebugger:cover
 
@@ -659,7 +682,7 @@ jobs:
         run: npm run test:cover:report
 
       - name: Upload HTML report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ runner.os }}-coverage-report-html
           path: ./coverage
diff --git a/.github/workflows/pr-file-check.yml b/.github/workflows/pr-file-check.yml
index fcdf91b4f64b..6364e5fa744e 100644
--- a/.github/workflows/pr-file-check.yml
+++ b/.github/workflows/pr-file-check.yml
@@ -9,13 +9,15 @@ on:
       - 'labeled'
       - 'unlabeled'
 
+permissions: {}
+
 jobs:
   changed-files-in-pr:
     name: 'Check for changed files'
     runs-on: ubuntu-latest
     steps:
       - name: 'package-lock.json matches package.json'
-        uses: brettcannon/check-for-changed-files@v1.2.1
+        uses: brettcannon/check-for-changed-files@871d7b8b5917a4f6f06662e2262e8ffc51dff6d1 # v1.2.1
         with:
           prereq-pattern: 'package.json'
           file-pattern: 'package-lock.json'
@@ -23,7 +25,7 @@ jobs:
           failure-message: '${prereq-pattern} was edited but ${file-pattern} was not (the ${skip-label} label can be used to pass this check)'
 
       - name: 'package.json matches package-lock.json'
-        uses: brettcannon/check-for-changed-files@v1.2.1
+        uses: brettcannon/check-for-changed-files@871d7b8b5917a4f6f06662e2262e8ffc51dff6d1 # v1.2.1
         with:
           prereq-pattern: 'package-lock.json'
           file-pattern: 'package.json'
@@ -31,7 +33,7 @@ jobs:
           failure-message: '${prereq-pattern} was edited but ${file-pattern} was not (the ${skip-label} label can be used to pass this check)'
 
       - name: 'Tests'
-        uses: brettcannon/check-for-changed-files@v1.2.1
+        uses: brettcannon/check-for-changed-files@871d7b8b5917a4f6f06662e2262e8ffc51dff6d1 # v1.2.1
         with:
           prereq-pattern: src/**/*.ts
           file-pattern: |
@@ -40,15 +42,3 @@ jobs:
             .github/test_plan.md
           skip-label: 'skip tests'
           failure-message: 'TypeScript code was edited without also editing a ${file-pattern} file; see the Testing page in our wiki on testing guidelines (the ${skip-label} label can be used to pass this check)'
-
-      - name: 'Ensure PR has an associated issue'
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const labels = context.payload.pull_request.labels.map(label => label.name);
-            if (!labels.includes('skip-issue-check')) {
-              const issueLink = context.payload.pull_request.body.match(/https:\/\/github\.com\/\S+\/issues\/\d+/);
-              if (!issueLink) {
-                core.setFailed('No associated issue found in the PR description.');
-              }
-            }
diff --git a/.github/workflows/pr-issue-check.yml b/.github/workflows/pr-issue-check.yml
new file mode 100644
index 000000000000..5587227d2848
--- /dev/null
+++ b/.github/workflows/pr-issue-check.yml
@@ -0,0 +1,31 @@
+name: PR issue check
+
+on:
+  pull_request:
+    types:
+      - 'opened'
+      - 'reopened'
+      - 'synchronize'
+      - 'labeled'
+      - 'unlabeled'
+
+permissions: {}
+
+jobs:
+  check-for-attached-issue:
+    name: 'Check for attached issue'
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Ensure PR has an associated issue'
+        uses: actions/github-script@v9
+        with:
+          script: |
+            const labels = context.payload.pull_request.labels.map(label => label.name);
+            if (!labels.includes('skip-issue-check')) {
+              const prBody = context.payload.pull_request.body || '';
+              const issueLink = prBody.match(/https:\/\/github\.com\/\S+\/issues\/\d+/);
+              const issueReference = prBody.match(/#\d+/);
+              if (!issueLink && !issueReference) {
+                core.setFailed('No associated issue found in the PR description.');
+              }
+            }
diff --git a/.github/workflows/pr-labels.yml b/.github/workflows/pr-labels.yml
index 730b8e5c5832..af24ac10772c 100644
--- a/.github/workflows/pr-labels.yml
+++ b/.github/workflows/pr-labels.yml
@@ -12,9 +12,12 @@ jobs:
   classify:
     name: 'Classify PR'
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
     steps:
       - name: 'PR impact specified'
-        uses: mheap/github-action-required-labels@v5
+        uses: mheap/github-action-required-labels@0ac283b4e65c1fb28ce6079dea5546ceca98ccbe # v5.5.2
         with:
           mode: exactly
           count: 1
diff --git a/.github/workflows/python27-issue-response.yml b/.github/workflows/python27-issue-response.yml
index 4d51e9921ab4..9db84bca1a23 100644
--- a/.github/workflows/python27-issue-response.yml
+++ b/.github/workflows/python27-issue-response.yml
@@ -5,6 +5,8 @@ on:
 jobs:
   python27-issue-response:
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
     if: "contains(github.event.issue.body, 'Python version (& distribution if applicable, e.g. Anaconda): 2.7')"
     steps:
       - name: Check for Python 2.7 string
diff --git a/.github/workflows/remove-needs-labels.yml b/.github/workflows/remove-needs-labels.yml
index 3d218e297a11..24352526d0d8 100644
--- a/.github/workflows/remove-needs-labels.yml
+++ b/.github/workflows/remove-needs-labels.yml
@@ -7,9 +7,11 @@ jobs:
   classify:
     name: 'Remove needs labels on issue closing'
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
     steps:
       - name: 'Removes needs labels on issue close'
-        uses: actions-ecosystem/action-remove-labels@v1
+        uses: actions-ecosystem/action-remove-labels@2ce5d41b4b6aa8503e285553f75ed56e0a40bae0 # v1.3.0
         with:
           labels: |
             needs PR
diff --git a/.github/workflows/test-plan-item-validator.yml b/.github/workflows/test-plan-item-validator.yml
index 17f1740345f2..57db4a3e18a7 100644
--- a/.github/workflows/test-plan-item-validator.yml
+++ b/.github/workflows/test-plan-item-validator.yml
@@ -12,10 +12,11 @@ jobs:
     if: contains(github.event.issue.labels.*.name, 'testplan-item') || contains(github.event.issue.labels.*.name, 'invalid-testplan-item')
     steps:
       - name: Checkout Actions
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/vscode-github-triage-actions'
           path: ./actions
+          persist-credentials: false
           ref: stable
 
       - name: Install Actions
diff --git a/.github/workflows/triage-info-needed.yml b/.github/workflows/triage-info-needed.yml
index 1ded54ea3f59..c7a37ba0c78d 100644
--- a/.github/workflows/triage-info-needed.yml
+++ b/.github/workflows/triage-info-needed.yml
@@ -7,20 +7,20 @@ on:
 env:
   TRIAGERS: '["karrtikr","karthiknadig","paulacamargo25","eleanorjboyd", "brettcannon","anthonykim1"]'
 
-permissions:
-  issues: write
-
 jobs:
   add_label:
-    runs-on: ubuntu-latest
     if: contains(github.event.issue.labels.*.name, 'triage-needed') && !contains(github.event.issue.labels.*.name, 'info-needed')
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
     steps:
       - name: Checkout Actions
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/vscode-github-triage-actions'
           ref: stable
           path: ./actions
+          persist-credentials: false
 
       - name: Install Actions
         run: npm install --production --prefix ./actions
@@ -35,13 +35,16 @@ jobs:
   remove_label:
     if: contains(github.event.issue.labels.*.name, 'info-needed') && contains(github.event.issue.labels.*.name, 'triage-needed')
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
     steps:
       - name: Checkout Actions
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           repository: 'microsoft/vscode-github-triage-actions'
           ref: stable
           path: ./actions
+          persist-credentials: false
 
       - name: Install Actions
         run: npm install --production --prefix ./actions
diff --git a/.gitignore b/.gitignore
index 1b47f15705bb..2fa056f84fa6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,3 +54,5 @@ python_files/tests/*/.data/.coverage*
 python_files/tests/*/.data/*/.coverage*
 src/testTestingRootWkspc/coverageWorkspace/.coverage
 
+# ignore ai artifacts generated and placed in this folder
+ai-artifacts/*
diff --git a/.nvmrc b/.nvmrc
index 67e145bf0f9d..c6a66a6e6a68 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-v20.18.0
+v22.21.1
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index e1468bdfc2ad..c5a054ed43cf 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -12,9 +12,7 @@
             "type": "npm",
             "script": "compile",
             "isBackground": true,
-            "problemMatcher": [
-                "$tsc-watch"
-            ],
+            "problemMatcher": ["$tsc-watch"],
             "group": {
                 "kind": "build",
                 "isDefault": true
@@ -34,6 +32,31 @@
             "script": "preTestJediLSP",
             "problemMatcher": [],
             "label": "preTestJediLSP"
+        },
+        {
+            "type": "npm",
+            "script": "check-python",
+            "problemMatcher": ["$python"],
+            "label": "npm: check-python",
+            "detail": "npm run check-python:ruff && npm run check-python:pyright"
+        },
+        {
+            "label": "npm: check-python (venv)",
+            "type": "shell",
+            "command": "bash",
+            "args": ["-lc", "source .venv/bin/activate && npm run check-python"],
+            "problemMatcher": [],
+            "detail": "Activates the repo .venv first (avoids pyenv/shim Python) then runs: npm run check-python",
+            "windows": {
+                "command": "pwsh",
+                "args": [
+                    "-NoProfile",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-Command",
+                    ".\\.venv\\Scripts\\Activate.ps1; npm run check-python"
+                ]
+            }
         }
     ]
 }
diff --git a/.vscodeignore b/.vscodeignore
index b94baaba1a19..d636ab48f361 100644
--- a/.vscodeignore
+++ b/.vscodeignore
@@ -1,5 +1,6 @@
 **/*.map
 **/*.analyzer.html
+**/.env
 *.vsix
 .editorconfig
 .env
diff --git a/README.md b/README.md
index b69de7351679..e9dd52a538cd 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Python extension for Visual Studio Code
 
-A [Visual Studio Code](https://code.visualstudio.com/) [extension](https://marketplace.visualstudio.com/VSCode) with rich support for the [Python language](https://www.python.org/) (for all [actively supported Python versions](https://devguide.python.org/versions/#supported-versions)), providing access points for extensions to seamlessly integrate and offer support for IntelliSense (Pylance), debugging (Python Debugger), formatting, linting, code navigation, refactoring, variable explorer, test explorer, and more!
+A [Visual Studio Code](https://code.visualstudio.com/) [extension](https://marketplace.visualstudio.com/VSCode) with rich support for the [Python language](https://www.python.org/) (for all [actively supported Python versions](https://devguide.python.org/versions/#supported-versions)), providing access points for extensions to seamlessly integrate and offer support for IntelliSense (Pylance), debugging (Python Debugger), formatting, linting, code navigation, refactoring, variable explorer, test explorer, environment management (**NEW** Python Environments Extension).
 
 ## Support for [vscode.dev](https://vscode.dev/)
 
@@ -11,11 +11,21 @@ The Python extension does offer [some support](https://github.com/microsoft/vsco
 
 The Python extension will automatically install the following extensions by default to provide the best Python development experience in VS Code:
 
-- [Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance) - to provide performant Python language support
-- [Python Debugger](https://marketplace.visualstudio.com/items?itemName=ms-python.debugpy) - to provide a seamless debug experience with debugpy
+- [Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance) – performant Python language support
+- [Python Debugger](https://marketplace.visualstudio.com/items?itemName=ms-python.debugpy) – seamless debug experience with debugpy
+- **(NEW)** [Python Environments](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-python-envs) – dedicated environment management (see below)
 
 These extensions are optional dependencies, meaning the Python extension will remain fully functional if they fail to be installed. Any or all of these extensions can be [disabled](https://code.visualstudio.com/docs/editor/extension-marketplace#_disable-an-extension) or [uninstalled](https://code.visualstudio.com/docs/editor/extension-marketplace#_uninstall-an-extension) at the expense of some features. Extensions installed through the marketplace are subject to the [Marketplace Terms of Use](https://cdn.vsassets.io/v/M146_20190123.39/_content/Microsoft-Visual-Studio-Marketplace-Terms-of-Use.pdf).
 
+### About the Python Environments Extension
+
+You may now see that the **Python Environments Extension** is installed for you, but it may or may not be "enabled" in your VS Code experience. Enablement is controlled by the setting `"python.useEnvironmentsExtension": true` (or `false`).
+
+- If you set this setting to `true`, you will manually opt in to using the Python Environments Extension for environment management.
+- If you do not have this setting specified, you may be randomly assigned to have it turned on as we roll it out until it becomes the default experience for all users.
+
+The Python Environments Extension is still under active development and experimentation. Its goal is to provide a dedicated view and improved workflows for creating, deleting, and switching between Python environments, as well as managing packages. If you have feedback, please let us know via [issues](https://github.com/microsoft/vscode-python/issues).
+
 ## Extensibility
 
 The Python extension provides pluggable access points for extensions that extend various feature areas to further improve your Python development experience. These extensions are all optional and depend on your project configuration and preferences.
@@ -27,7 +37,7 @@ If you encounter issues with any of the listed extensions, please file an issue
 
 ## Quick start
 
--   **Step 1.** [Install a supported version of Python on your system](https://code.visualstudio.com/docs/python/python-tutorial#_prerequisites) (note: that the system install of Python on macOS is not supported).
+-   **Step 1.** [Install a supported version of Python on your system](https://code.visualstudio.com/docs/python/python-tutorial#_prerequisites) (note: the system install of Python on macOS is not supported).
 -   **Step 2.** [Install the Python extension for Visual Studio Code](https://code.visualstudio.com/docs/editor/extension-gallery).
 -   **Step 3.** Open or create a Python file and start coding!
 
@@ -80,13 +90,13 @@ To see all available Python commands, open the Command Palette and type `Python`
 
 Learn more about the rich features of the Python extension:
 
--   [IntelliSense](https://code.visualstudio.com/docs/python/editing#_autocomplete-and-intellisense): Edit your code with auto-completion, code navigation, syntax checking and more
--   [Linting](https://code.visualstudio.com/docs/python/linting): Get additional code analysis with Pylint, Flake8 and more
--   [Code formatting](https://code.visualstudio.com/docs/python/formatting): Format your code with black, autopep or yapf
--   [Debugging](https://code.visualstudio.com/docs/python/debugging): Debug your Python scripts, web apps, remote or multi-threaded processes
+-   [IntelliSense](https://code.visualstudio.com/docs/python/editing#_autocomplete-and-intellisense): Edit your code with auto-completion, code navigation, syntax checking and more.
+-   [Linting](https://code.visualstudio.com/docs/python/linting): Get additional code analysis with Pylint, Flake8 and more.
+-   [Code formatting](https://code.visualstudio.com/docs/python/formatting): Format your code with black, autopep or yapf.
+-   [Debugging](https://code.visualstudio.com/docs/python/debugging): Debug your Python scripts, web apps, remote or multi-threaded processes.
 -   [Testing](https://code.visualstudio.com/docs/python/unit-testing): Run and debug tests through the Test Explorer with unittest or pytest.
--   [Jupyter Notebooks](https://code.visualstudio.com/docs/python/jupyter-support): Create and edit Jupyter Notebooks, add and run code cells, render plots, visualize variables through the variable explorer, visualize dataframes with the data viewer, and more
--   [Environments](https://code.visualstudio.com/docs/python/environments): Automatically activate and switch between virtualenv, venv, pipenv, conda and pyenv environments
+-   [Jupyter Notebooks](https://code.visualstudio.com/docs/python/jupyter-support): Create and edit Jupyter Notebooks, add and run code cells, render plots, visualize variables through the variable explorer, visualize dataframes with the data viewer, and more.
+-   [Environments](https://code.visualstudio.com/docs/python/environments): Automatically activate and switch between virtualenv, venv, pipenv, conda and pyenv environments.
 -   [Refactoring](https://code.visualstudio.com/docs/python/editing#_refactoring): Restructure your Python code with variable extraction and method extraction. Additionally, there is componentized support to enable additional refactoring, such as import sorting, through extensions including [isort](https://marketplace.visualstudio.com/items?itemName=ms-python.isort) and [Ruff](https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff).
 
 
@@ -111,6 +121,6 @@ The Microsoft Python Extension for Visual Studio Code collects usage
 data and sends it to Microsoft to help improve our products and
 services. Read our
 [privacy statement](https://privacy.microsoft.com/privacystatement) to
-learn more. This extension respects the `telemetry.enableTelemetry`
+learn more. This extension respects the `telemetry.telemetryLevel`
 setting which you can learn more about at
 https://code.visualstudio.com/docs/supporting/faq#_how-to-disable-telemetry-reporting.
diff --git a/build/azure-pipeline.pre-release.yml b/build/azure-pipeline.pre-release.yml
index 8a631394a7fb..c300039f4ef4 100644
--- a/build/azure-pipeline.pre-release.yml
+++ b/build/azure-pipeline.pre-release.yml
@@ -66,12 +66,12 @@ extends:
     buildSteps:
       - task: NodeTool@0
         inputs:
-          versionSpec: '20.18.0'
+          versionSpec: '22.17.0'
         displayName: Select Node version
 
       - task: UsePythonVersion@0
         inputs:
-          versionSpec: '3.8'
+          versionSpec: '3.10'
           addToPath: true
           architecture: 'x64'
         displayName: Select Python version
@@ -102,6 +102,32 @@ extends:
             chmod +x $(Build.SourcesDirectory)/python-env-tools/bin
         displayName: Make Directory for python-env-tool binary
 
+      - bash: |
+          if [ "$(vsceTarget)" == "win32-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-pc-windows-msvc"
+          elif [ "$(vsceTarget)" == "win32-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-pc-windows-msvc"
+          elif [ "$(vsceTarget)" == "linux-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          elif [ "$(vsceTarget)" == "linux-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-unknown-linux-gnu"
+          elif [ "$(vsceTarget)" == "linux-armhf" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]armv7-unknown-linux-gnueabihf"
+          elif [ "$(vsceTarget)" == "darwin-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-apple-darwin"
+          elif [ "$(vsceTarget)" == "darwin-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-apple-darwin"
+          elif [ "$(vsceTarget)" == "alpine-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          elif [ "$(vsceTarget)" == "alpine-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-unknown-linux-gnu"
+          elif [ "$(vsceTarget)" == "web" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          else
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          fi
+        displayName: Set buildTarget variable
+
       - task: DownloadPipelineArtifact@2
         inputs:
             buildType: 'specific'
@@ -110,7 +136,7 @@ extends:
             buildVersionToDownload: 'latest'
             branchName: 'refs/heads/main'
             targetPath: '$(Build.SourcesDirectory)/python-env-tools/bin'
-            artifactName: 'bin-$(vsceTarget)'
+            artifactName: 'bin-$(buildTarget)'
             itemPattern: |
               pet.exe
               pet
diff --git a/build/azure-pipeline.stable.yml b/build/azure-pipeline.stable.yml
index a5276bbb09d2..024417da0e00 100644
--- a/build/azure-pipeline.stable.yml
+++ b/build/azure-pipeline.stable.yml
@@ -60,12 +60,12 @@ extends:
     buildSteps:
       - task: NodeTool@0
         inputs:
-          versionSpec: '20.18.0'
+          versionSpec: '22.17.0'
         displayName: Select Node version
 
       - task: UsePythonVersion@0
         inputs:
-          versionSpec: '3.8'
+          versionSpec: '3.10'
           addToPath: true
           architecture: 'x64'
         displayName: Select Python version
@@ -92,36 +92,62 @@ extends:
         displayName: Build
 
       - bash: |
-            mkdir -p $(Build.SourcesDirectory)/python-env-tools/bin
-            chmod +x $(Build.SourcesDirectory)/python-env-tools/bin
+          mkdir -p $(Build.SourcesDirectory)/python-env-tools/bin
+          chmod +x $(Build.SourcesDirectory)/python-env-tools/bin
         displayName: Make Directory for python-env-tool binary
 
+      - bash: |
+          if [ "$(vsceTarget)" == "win32-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-pc-windows-msvc"
+          elif [ "$(vsceTarget)" == "win32-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-pc-windows-msvc"
+          elif [ "$(vsceTarget)" == "linux-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          elif [ "$(vsceTarget)" == "linux-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-unknown-linux-gnu"
+          elif [ "$(vsceTarget)" == "linux-armhf" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]armv7-unknown-linux-gnueabihf"
+          elif [ "$(vsceTarget)" == "darwin-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-apple-darwin"
+          elif [ "$(vsceTarget)" == "darwin-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-apple-darwin"
+          elif [ "$(vsceTarget)" == "alpine-x64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          elif [ "$(vsceTarget)" == "alpine-arm64" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]aarch64-unknown-linux-gnu"
+          elif [ "$(vsceTarget)" == "web" ]; then
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          else
+            echo "##vso[task.setvariable variable=buildTarget]x86_64-unknown-linux-musl"
+          fi
+        displayName: Set buildTarget variable
+
       - task: DownloadPipelineArtifact@2
         inputs:
-            buildType: 'specific'
-            project: 'Monaco'
-            definition: 593
-            buildVersionToDownload: 'latestFromBranch'
-            branchName: 'refs/heads/release/2025.2'
-            targetPath: '$(Build.SourcesDirectory)/python-env-tools/bin'
-            artifactName: 'bin-$(vsceTarget)'
-            itemPattern: |
-              pet.exe
-              pet
-              ThirdPartyNotices.txt
+          buildType: 'specific'
+          project: 'Monaco'
+          definition: 593
+          buildVersionToDownload: 'latestFromBranch'
+          branchName: 'refs/heads/release/2026.4'
+          targetPath: '$(Build.SourcesDirectory)/python-env-tools/bin'
+          artifactName: 'bin-$(buildTarget)'
+          itemPattern: |
+            pet.exe
+            pet
+            ThirdPartyNotices.txt
 
       - bash: |
-            ls -lf ./python-env-tools/bin
-            chmod +x ./python-env-tools/bin/pet*
-            ls -lf ./python-env-tools/bin
+          ls -lf ./python-env-tools/bin
+          chmod +x ./python-env-tools/bin/pet*
+          ls -lf ./python-env-tools/bin
         displayName: Set chmod for pet binary
 
       - script: python -c "import shutil; shutil.rmtree('.nox', ignore_errors=True)"
         displayName: Clean up Nox
     tsa:
-        config:
-            areaPath: 'Visual Studio Code Python Extensions'
-            serviceTreeID: '6e6194bc-7baa-4486-86d0-9f5419626d46'
-        enabled: true
+      config:
+        areaPath: 'Visual Studio Code Python Extensions'
+        serviceTreeID: '6e6194bc-7baa-4486-86d0-9f5419626d46'
+      enabled: true
     apiScanDependentPipelineId: '593' # python-environment-tools
     apiScanSoftwareVersion: '2024'
diff --git a/build/azure-pipelines/pipeline.yml b/build/azure-pipelines/pipeline.yml
index 7b611de683a8..0796e38ca598 100644
--- a/build/azure-pipelines/pipeline.yml
+++ b/build/azure-pipelines/pipeline.yml
@@ -37,13 +37,13 @@ extends:
         testPlatforms:
           - name: Linux
             nodeVersions:
-              - 20.18.0
+              - 22.21.1
           - name: MacOS
             nodeVersions:
-              - 20.18.0
+              - 22.21.1
           - name: Windows
             nodeVersions:
-              - 20.18.0
+              - 22.21.1
         testSteps:
           - template: /build/azure-pipelines/templates/test-steps.yml@self
             parameters:
diff --git a/build/ci/conda_env_1.yml b/build/ci/conda_env_1.yml
index e9d08d0820a4..e3230ad0096e 100644
--- a/build/ci/conda_env_1.yml
+++ b/build/ci/conda_env_1.yml
@@ -1,4 +1,4 @@
 name: conda_env_1
 dependencies:
-  - python=3.8
+  - python=3.10
   - pip
diff --git a/build/ci/conda_env_2.yml b/build/ci/conda_env_2.yml
index 80b946c3cc14..38f551da2580 100644
--- a/build/ci/conda_env_2.yml
+++ b/build/ci/conda_env_2.yml
@@ -1,4 +1,4 @@
 name: conda_env_2
 dependencies:
-  - python=3.8
+  - python=3.10
   - pip
diff --git a/build/test-requirements.txt b/build/test-requirements.txt
index 8b0ea1636157..ff9afdfc8a2e 100644
--- a/build/test-requirements.txt
+++ b/build/test-requirements.txt
@@ -12,8 +12,8 @@ flask
 fastapi
 uvicorn
 django
-testresources
 testscenarios
+testtools
 
 # Integrated TensorBoard tests
 tensorboard
@@ -28,10 +28,10 @@ namedpipe; platform_system == "Windows"
 # typing for Django files
 django-stubs
 
-# for coverage
 coverage
 pytest-cov
 pytest-json
+pytest-timeout
 
 
 # for pytest-describe related tests
@@ -39,3 +39,4 @@ pytest-describe
 
 # for pytest-ruff related tests
 pytest-ruff
+pytest-black
diff --git a/gulpfile.js b/gulpfile.js
index f921ff7fd1b1..0b919f16572a 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -98,9 +98,11 @@ async function addExtensionPackDependencies() {
     // extension dependencies need not be installed during development
     const packageJsonContents = await fsExtra.readFile('package.json', 'utf-8');
     const packageJson = JSON.parse(packageJsonContents);
-    packageJson.extensionPack = ['ms-python.vscode-pylance', 'ms-python.debugpy'].concat(
-        packageJson.extensionPack ? packageJson.extensionPack : [],
-    );
+    packageJson.extensionPack = [
+        'ms-python.vscode-pylance',
+        'ms-python.debugpy',
+        'ms-python.vscode-python-envs',
+    ].concat(packageJson.extensionPack ? packageJson.extensionPack : []);
     // Remove potential duplicates.
     packageJson.extensionPack = packageJson.extensionPack.filter(
         (item, index) => packageJson.extensionPack.indexOf(item) === index,
diff --git a/package-lock.json b/package-lock.json
index 10866a3d9ca1..82053df77576 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,15 +1,15 @@
 {
     "name": "python",
-    "version": "2025.3.0-dev",
+    "version": "2026.5.0-dev",
     "lockfileVersion": 2,
     "requires": true,
     "packages": {
         "": {
             "name": "python",
-            "version": "2025.3.0-dev",
+            "version": "2026.5.0-dev",
             "license": "MIT",
             "dependencies": {
-                "@iarna/toml": "^2.2.5",
+                "@iarna/toml": "^3.0.0",
                 "@vscode/extension-telemetry": "^0.8.4",
                 "arch": "^2.1.0",
                 "fs-extra": "^11.2.0",
@@ -17,8 +17,8 @@
                 "iconv-lite": "^0.6.3",
                 "inversify": "^6.0.2",
                 "jsonc-parser": "^3.0.0",
-                "lodash": "^4.17.21",
-                "minimatch": "^5.0.1",
+                "lodash": "^4.18.1",
+                "minimatch": "^5.1.8",
                 "named-js-regexp": "^1.3.3",
                 "node-stream-zip": "^1.6.0",
                 "reflect-metadata": "^0.2.2",
@@ -27,7 +27,7 @@
                 "semver": "^7.5.2",
                 "stack-trace": "0.0.10",
                 "sudo-prompt": "^9.2.1",
-                "tmp": "^0.0.33",
+                "tmp": "^0.2.5",
                 "uint64be": "^3.0.0",
                 "unicode": "^14.0.0",
                 "vscode-debugprotocol": "^1.28.0",
@@ -50,13 +50,13 @@
                 "@types/glob": "^7.2.0",
                 "@types/lodash": "^4.14.104",
                 "@types/mocha": "^9.1.0",
-                "@types/node": "^22.5.0",
+                "@types/node": "^22.19.1",
                 "@types/semver": "^5.5.0",
                 "@types/shortid": "^0.0.29",
                 "@types/sinon": "^17.0.3",
                 "@types/stack-trace": "0.0.29",
                 "@types/tmp": "^0.0.33",
-                "@types/vscode": "^1.93.0",
+                "@types/vscode": "^1.95.0",
                 "@types/which": "^2.0.1",
                 "@types/winreg": "^1.2.30",
                 "@types/xml2js": "^0.4.2",
@@ -103,8 +103,8 @@
                 "tsconfig-paths-webpack-plugin": "^3.2.0",
                 "typemoq": "^2.1.0",
                 "typescript": "~5.2",
-                "uuid": "^8.3.2",
-                "webpack": "^5.76.0",
+                "uuid": "^14.0.0",
+                "webpack": "^5.105.0",
                 "webpack-bundle-analyzer": "^4.5.0",
                 "webpack-cli": "^4.9.2",
                 "webpack-fix-default-import-plugin": "^1.0.3",
@@ -115,7 +115,7 @@
                 "yargs": "^15.3.1"
             },
             "engines": {
-                "vscode": "^1.94.0-20240918"
+                "vscode": "^1.95.0"
             }
         },
         "node_modules/@aashutoshrathi/word-wrap": {
@@ -285,6 +285,14 @@
             "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
             "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="
         },
+        "node_modules/@azure/core-rest-pipeline/node_modules/uuid": {
+            "version": "8.3.2",
+            "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+            "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+            "bin": {
+                "uuid": "dist/bin/uuid"
+            }
+        },
         "node_modules/@azure/core-tracing": {
             "version": "1.0.1",
             "resolved": "https://registry.npmjs.org/@azure/core-tracing/-/core-tracing-1.0.1.tgz",
@@ -434,6 +442,15 @@
                 "node": ">=0.8.0"
             }
         },
+        "node_modules/@azure/msal-node/node_modules/uuid": {
+            "version": "8.3.2",
+            "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+            "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+            "dev": true,
+            "bin": {
+                "uuid": "dist/bin/uuid"
+            }
+        },
         "node_modules/@azure/opentelemetry-instrumentation-azure-sdk": {
             "version": "1.0.0-beta.5",
             "resolved": "https://registry.npmjs.org/@azure/opentelemetry-instrumentation-azure-sdk/-/opentelemetry-instrumentation-azure-sdk-1.0.0-beta.5.tgz",
@@ -455,6 +472,21 @@
             "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
             "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="
         },
+        "node_modules/@babel/code-frame": {
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+            "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@babel/helper-validator-identifier": "^7.27.1",
+                "js-tokens": "^4.0.0",
+                "picocolors": "^1.1.1"
+            },
+            "engines": {
+                "node": ">=6.9.0"
+            }
+        },
         "node_modules/@babel/compat-data": {
             "version": "7.22.6",
             "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.22.6.tgz",
@@ -494,18 +526,6 @@
                 "url": "https://opencollective.com/babel"
             }
         },
-        "node_modules/@babel/core/node_modules/@babel/code-frame": {
-            "version": "7.22.5",
-            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.5.tgz",
-            "integrity": "sha512-Xmwn266vad+6DAqEB2A6V/CcZVp62BbwVmcOJc2RPuwih1kw02TjQvWVWlcKGbBPd+8/0V5DEkOcizRGYsspYQ==",
-            "dev": true,
-            "dependencies": {
-                "@babel/highlight": "^7.22.5"
-            },
-            "engines": {
-                "node": ">=6.9.0"
-            }
-        },
         "node_modules/@babel/core/node_modules/debug": {
             "version": "4.3.4",
             "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
@@ -662,19 +682,21 @@
             }
         },
         "node_modules/@babel/helper-string-parser": {
-            "version": "7.22.5",
-            "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz",
-            "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+            "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
             "dev": true,
+            "license": "MIT",
             "engines": {
                 "node": ">=6.9.0"
             }
         },
         "node_modules/@babel/helper-validator-identifier": {
-            "version": "7.22.20",
-            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz",
-            "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+            "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
             "dev": true,
+            "license": "MIT",
             "engines": {
                 "node": ">=6.9.0"
             }
@@ -689,38 +711,28 @@
             }
         },
         "node_modules/@babel/helpers": {
-            "version": "7.22.6",
-            "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.22.6.tgz",
-            "integrity": "sha512-YjDs6y/fVOYFV8hAf1rxd1QvR9wJe1pDBZ2AREKq/SDayfPzgk0PBnVuTCE5X1acEpMMNOVUqoe+OwiZGJ+OaA==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.1.tgz",
+            "integrity": "sha512-FCvFTm0sWV8Fxhpp2McP5/W53GPllQ9QeQ7SiqGWjMf/LVG07lFa5+pgK05IRhVwtvafT22KF+ZSnM9I545CvQ==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "@babel/template": "^7.22.5",
-                "@babel/traverse": "^7.22.6",
-                "@babel/types": "^7.22.5"
+                "@babel/template": "^7.27.1",
+                "@babel/types": "^7.27.1"
             },
             "engines": {
                 "node": ">=6.9.0"
             }
         },
-        "node_modules/@babel/highlight": {
-            "version": "7.22.20",
-            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz",
-            "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==",
+        "node_modules/@babel/parser": {
+            "version": "7.27.2",
+            "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.2.tgz",
+            "integrity": "sha512-QYLs8299NA7WM/bZAdp+CviYYkVoYXlDW2rzliy3chxd1PQjej7JORuMJDJXJUb9g0TT+B99EwaVLKmX+sPXWw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "@babel/helper-validator-identifier": "^7.22.20",
-                "chalk": "^2.4.2",
-                "js-tokens": "^4.0.0"
+                "@babel/types": "^7.27.1"
             },
-            "engines": {
-                "node": ">=6.9.0"
-            }
-        },
-        "node_modules/@babel/parser": {
-            "version": "7.23.0",
-            "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.0.tgz",
-            "integrity": "sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==",
-            "dev": true,
             "bin": {
                 "parser": "bin/babel-parser.js"
             },
@@ -729,49 +741,38 @@
             }
         },
         "node_modules/@babel/runtime": {
-            "version": "7.17.8",
-            "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.17.8.tgz",
-            "integrity": "sha512-dQpEpK0O9o6lj6oPu0gRDbbnk+4LeHlNcBpspf6Olzt3GIX4P1lWF1gS+pHLDFlaJvbR6q7jCfQ08zA4QJBnmA==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz",
+            "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==",
             "dev": true,
-            "dependencies": {
-                "regenerator-runtime": "^0.13.4"
-            },
+            "license": "MIT",
             "engines": {
                 "node": ">=6.9.0"
             }
         },
         "node_modules/@babel/runtime-corejs3": {
-            "version": "7.10.5",
-            "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.10.5.tgz",
-            "integrity": "sha512-RMafpmrNB5E/bwdSphLr8a8++9TosnyJp98RZzI6VOx2R2CCMpsXXXRvmI700O9oEKpXdZat6oEK68/F0zjd4A==",
-            "dev": true,
-            "dependencies": {
-                "core-js-pure": "^3.0.0",
-                "regenerator-runtime": "^0.13.4"
-            }
-        },
-        "node_modules/@babel/template": {
-            "version": "7.22.15",
-            "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz",
-            "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.27.1.tgz",
+            "integrity": "sha512-909rVuj3phpjW6y0MCXAZ5iNeORePa6ldJvp2baWGcTjwqbBDDz6xoS5JHJ7lS88NlwLYj07ImL/8IUMtDZzTA==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "@babel/code-frame": "^7.22.13",
-                "@babel/parser": "^7.22.15",
-                "@babel/types": "^7.22.15"
+                "core-js-pure": "^3.30.2"
             },
             "engines": {
                 "node": ">=6.9.0"
             }
         },
-        "node_modules/@babel/template/node_modules/@babel/code-frame": {
-            "version": "7.22.13",
-            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz",
-            "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==",
+        "node_modules/@babel/template": {
+            "version": "7.27.2",
+            "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+            "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "@babel/highlight": "^7.22.13",
-                "chalk": "^2.4.2"
+                "@babel/code-frame": "^7.27.1",
+                "@babel/parser": "^7.27.2",
+                "@babel/types": "^7.27.1"
             },
             "engines": {
                 "node": ">=6.9.0"
@@ -798,19 +799,6 @@
                 "node": ">=6.9.0"
             }
         },
-        "node_modules/@babel/traverse/node_modules/@babel/code-frame": {
-            "version": "7.22.13",
-            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz",
-            "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==",
-            "dev": true,
-            "dependencies": {
-                "@babel/highlight": "^7.22.13",
-                "chalk": "^2.4.2"
-            },
-            "engines": {
-                "node": ">=6.9.0"
-            }
-        },
         "node_modules/@babel/traverse/node_modules/debug": {
             "version": "4.3.4",
             "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
@@ -829,14 +817,14 @@
             }
         },
         "node_modules/@babel/types": {
-            "version": "7.23.0",
-            "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.0.tgz",
-            "integrity": "sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz",
+            "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "@babel/helper-string-parser": "^7.22.5",
-                "@babel/helper-validator-identifier": "^7.22.20",
-                "to-fast-properties": "^2.0.0"
+                "@babel/helper-string-parser": "^7.27.1",
+                "@babel/helper-validator-identifier": "^7.27.1"
             },
             "engines": {
                 "node": ">=6.9.0"
@@ -962,11 +950,10 @@
             }
         },
         "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
-            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-            "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+            "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
             "dev": true,
-            "license": "MIT",
             "dependencies": {
                 "argparse": "^2.0.1"
             },
@@ -975,9 +962,9 @@
             }
         },
         "node_modules/@eslint/eslintrc/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
             "license": "ISC",
             "dependencies": {
@@ -1073,9 +1060,9 @@
             }
         },
         "node_modules/@humanwhocodes/config-array/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
             "license": "ISC",
             "dependencies": {
@@ -1115,9 +1102,10 @@
             "license": "BSD-3-Clause"
         },
         "node_modules/@iarna/toml": {
-            "version": "2.2.5",
-            "resolved": "https://registry.npmjs.org/@iarna/toml/-/toml-2.2.5.tgz",
-            "integrity": "sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg=="
+            "version": "3.0.0",
+            "resolved": "https://registry.npmjs.org/@iarna/toml/-/toml-3.0.0.tgz",
+            "integrity": "sha512-td6ZUkz2oS3VeleBcN+m//Q6HlCFCPrnI0FZhrt/h4XqLEdOyYp2u21nd8MdsR+WJy5r9PTDaHTDDfhf4H4l6Q==",
+            "license": "ISC"
         },
         "node_modules/@isaacs/cliui": {
             "version": "8.0.2",
@@ -1294,9 +1282,9 @@
             }
         },
         "node_modules/@jridgewell/source-map": {
-            "version": "0.3.6",
-            "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
-            "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
+            "version": "0.3.11",
+            "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+            "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
             "dev": true,
             "dependencies": {
                 "@jridgewell/gen-mapping": "^0.3.5",
@@ -1809,10 +1797,30 @@
                 "@types/node": "*"
             }
         },
+        "node_modules/@types/eslint": {
+            "version": "9.6.1",
+            "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz",
+            "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
+            "dev": true,
+            "dependencies": {
+                "@types/estree": "*",
+                "@types/json-schema": "*"
+            }
+        },
+        "node_modules/@types/eslint-scope": {
+            "version": "3.7.7",
+            "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
+            "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
+            "dev": true,
+            "dependencies": {
+                "@types/eslint": "*",
+                "@types/estree": "*"
+            }
+        },
         "node_modules/@types/estree": {
-            "version": "1.0.5",
-            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
-            "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+            "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
             "dev": true
         },
         "node_modules/@types/fs-extra": {
@@ -1847,19 +1855,42 @@
             }
         },
         "node_modules/@types/got/node_modules/form-data": {
-            "version": "2.5.1",
-            "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz",
-            "integrity": "sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==",
+            "version": "2.5.5",
+            "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.5.tgz",
+            "integrity": "sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A==",
             "dev": true,
             "dependencies": {
                 "asynckit": "^0.4.0",
-                "combined-stream": "^1.0.6",
-                "mime-types": "^2.1.12"
+                "combined-stream": "^1.0.8",
+                "es-set-tostringtag": "^2.1.0",
+                "hasown": "^2.0.2",
+                "mime-types": "^2.1.35",
+                "safe-buffer": "^5.2.1"
             },
             "engines": {
                 "node": ">= 0.12"
             }
         },
+        "node_modules/@types/got/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ]
+        },
         "node_modules/@types/json-schema": {
             "version": "7.0.15",
             "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
@@ -1900,12 +1931,13 @@
             "dev": true
         },
         "node_modules/@types/node": {
-            "version": "22.5.0",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.5.0.tgz",
-            "integrity": "sha512-DkFrJOe+rfdHTqqMg0bSNlGlQ85hSoh2TPzZyhHsXnMtligRWpxUySiyw8FY14ITt24HVCiQPWxS3KO/QlGmWg==",
+            "version": "22.19.3",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.3.tgz",
+            "integrity": "sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "undici-types": "~6.19.2"
+                "undici-types": "~6.21.0"
             }
         },
         "node_modules/@types/semver": {
@@ -1959,10 +1991,11 @@
             "dev": true
         },
         "node_modules/@types/vscode": {
-            "version": "1.93.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.93.0.tgz",
-            "integrity": "sha512-kUK6jAHSR5zY8ps42xuW89NLcBpw1kOabah7yv38J8MyiYuOHxLQBi0e7zeXbQgVefDy/mZZetqEFC+Fl5eIEQ==",
-            "dev": true
+            "version": "1.100.0",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.100.0.tgz",
+            "integrity": "sha512-4uNyvzHoraXEeCamR3+fzcBlh7Afs4Ifjs4epINyUX/jvdk0uzLnwiDY35UKDKnkCHP5Nu3dljl2H8lR6s+rQw==",
+            "dev": true,
+            "license": "MIT"
         },
         "node_modules/@types/which": {
             "version": "2.0.1",
@@ -2185,9 +2218,9 @@
             }
         },
         "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-            "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+            "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
             "dev": true,
             "dependencies": {
                 "balanced-match": "^1.0.0"
@@ -2507,10 +2540,11 @@
             }
         },
         "node_modules/@vscode/vsce/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -2518,161 +2552,149 @@
                 "node": "*"
             }
         },
-        "node_modules/@vscode/vsce/node_modules/tmp": {
-            "version": "0.2.1",
-            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz",
-            "integrity": "sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==",
-            "dev": true,
-            "dependencies": {
-                "rimraf": "^3.0.0"
-            },
-            "engines": {
-                "node": ">=8.17.0"
-            }
-        },
         "node_modules/@webassemblyjs/ast": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
-            "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+            "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/helper-numbers": "1.11.6",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
+                "@webassemblyjs/helper-numbers": "1.13.2",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
             }
         },
         "node_modules/@webassemblyjs/floating-point-hex-parser": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz",
-            "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
+            "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==",
             "dev": true
         },
         "node_modules/@webassemblyjs/helper-api-error": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz",
-            "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
+            "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==",
             "dev": true
         },
         "node_modules/@webassemblyjs/helper-buffer": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
-            "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
+            "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==",
             "dev": true
         },
         "node_modules/@webassemblyjs/helper-numbers": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz",
-            "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
+            "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/floating-point-hex-parser": "1.11.6",
-                "@webassemblyjs/helper-api-error": "1.11.6",
+                "@webassemblyjs/floating-point-hex-parser": "1.13.2",
+                "@webassemblyjs/helper-api-error": "1.13.2",
                 "@xtuc/long": "4.2.2"
             }
         },
         "node_modules/@webassemblyjs/helper-wasm-bytecode": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz",
-            "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
+            "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==",
             "dev": true
         },
         "node_modules/@webassemblyjs/helper-wasm-section": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
-            "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
+            "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-buffer": "1.12.1",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/wasm-gen": "1.12.1"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-buffer": "1.14.1",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/wasm-gen": "1.14.1"
             }
         },
         "node_modules/@webassemblyjs/ieee754": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz",
-            "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
+            "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
             "dev": true,
             "dependencies": {
                 "@xtuc/ieee754": "^1.2.0"
             }
         },
         "node_modules/@webassemblyjs/leb128": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz",
-            "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
+            "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
             "dev": true,
             "dependencies": {
                 "@xtuc/long": "4.2.2"
             }
         },
         "node_modules/@webassemblyjs/utf8": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz",
-            "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
+            "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==",
             "dev": true
         },
         "node_modules/@webassemblyjs/wasm-edit": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
-            "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
+            "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-buffer": "1.12.1",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/helper-wasm-section": "1.12.1",
-                "@webassemblyjs/wasm-gen": "1.12.1",
-                "@webassemblyjs/wasm-opt": "1.12.1",
-                "@webassemblyjs/wasm-parser": "1.12.1",
-                "@webassemblyjs/wast-printer": "1.12.1"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-buffer": "1.14.1",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/helper-wasm-section": "1.14.1",
+                "@webassemblyjs/wasm-gen": "1.14.1",
+                "@webassemblyjs/wasm-opt": "1.14.1",
+                "@webassemblyjs/wasm-parser": "1.14.1",
+                "@webassemblyjs/wast-printer": "1.14.1"
             }
         },
         "node_modules/@webassemblyjs/wasm-gen": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
-            "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
+            "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/ieee754": "1.11.6",
-                "@webassemblyjs/leb128": "1.11.6",
-                "@webassemblyjs/utf8": "1.11.6"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/ieee754": "1.13.2",
+                "@webassemblyjs/leb128": "1.13.2",
+                "@webassemblyjs/utf8": "1.13.2"
             }
         },
         "node_modules/@webassemblyjs/wasm-opt": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
-            "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
+            "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-buffer": "1.12.1",
-                "@webassemblyjs/wasm-gen": "1.12.1",
-                "@webassemblyjs/wasm-parser": "1.12.1"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-buffer": "1.14.1",
+                "@webassemblyjs/wasm-gen": "1.14.1",
+                "@webassemblyjs/wasm-parser": "1.14.1"
             }
         },
         "node_modules/@webassemblyjs/wasm-parser": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
-            "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
+            "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-api-error": "1.11.6",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/ieee754": "1.11.6",
-                "@webassemblyjs/leb128": "1.11.6",
-                "@webassemblyjs/utf8": "1.11.6"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-api-error": "1.13.2",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/ieee754": "1.13.2",
+                "@webassemblyjs/leb128": "1.13.2",
+                "@webassemblyjs/utf8": "1.13.2"
             }
         },
         "node_modules/@webassemblyjs/wast-printer": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
-            "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
+            "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
             "dev": true,
             "dependencies": {
-                "@webassemblyjs/ast": "1.12.1",
+                "@webassemblyjs/ast": "1.14.1",
                 "@xtuc/long": "4.2.2"
             }
         },
@@ -2725,10 +2747,9 @@
             "dev": true
         },
         "node_modules/acorn": {
-            "version": "8.14.1",
-            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz",
-            "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
-            "license": "MIT",
+            "version": "8.15.0",
+            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+            "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
             "bin": {
                 "acorn": "bin/acorn"
             },
@@ -2744,13 +2765,16 @@
                 "acorn": "^8"
             }
         },
-        "node_modules/acorn-import-attributes": {
-            "version": "1.9.5",
-            "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
-            "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
+        "node_modules/acorn-import-phases": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz",
+            "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==",
             "dev": true,
+            "engines": {
+                "node": ">=10.13.0"
+            },
             "peerDependencies": {
-                "acorn": "^8"
+                "acorn": "^8.14.0"
             }
         },
         "node_modules/acorn-jsx": {
@@ -2813,10 +2837,11 @@
             }
         },
         "node_modules/ajv": {
-            "version": "6.12.6",
-            "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-            "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+            "version": "6.14.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+            "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
                 "fast-deep-equal": "^3.1.1",
                 "fast-json-stable-stringify": "^2.0.0",
@@ -2828,6 +2853,46 @@
                 "url": "https://github.com/sponsors/epoberezkin"
             }
         },
+        "node_modules/ajv-formats": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
+            "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+            "dev": true,
+            "dependencies": {
+                "ajv": "^8.0.0"
+            },
+            "peerDependencies": {
+                "ajv": "^8.0.0"
+            },
+            "peerDependenciesMeta": {
+                "ajv": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/ajv-formats/node_modules/ajv": {
+            "version": "8.18.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+            "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3",
+                "fast-uri": "^3.0.1",
+                "json-schema-traverse": "^1.0.0",
+                "require-from-string": "^2.0.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/ajv-formats/node_modules/json-schema-traverse": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+            "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+            "dev": true
+        },
         "node_modules/ajv-keywords": {
             "version": "3.5.2",
             "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
@@ -3179,15 +3244,15 @@
             }
         },
         "node_modules/asn1.js": {
-            "version": "5.4.1",
-            "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz",
-            "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==",
+            "version": "4.10.1",
+            "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz",
+            "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
                 "bn.js": "^4.0.0",
                 "inherits": "^2.0.1",
-                "minimalistic-assert": "^1.0.0",
-                "safer-buffer": "^2.1.0"
+                "minimalistic-assert": "^1.0.0"
             }
         },
         "node_modules/assert": {
@@ -3435,6 +3500,15 @@
                 }
             ]
         },
+        "node_modules/baseline-browser-mapping": {
+            "version": "2.9.19",
+            "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz",
+            "integrity": "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==",
+            "dev": true,
+            "bin": {
+                "baseline-browser-mapping": "dist/cli.js"
+            }
+        },
         "node_modules/bent": {
             "version": "7.3.12",
             "resolved": "https://registry.npmjs.org/bent/-/bent-7.3.12.tgz",
@@ -3488,10 +3562,11 @@
             }
         },
         "node_modules/bn.js": {
-            "version": "4.11.8",
-            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz",
-            "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==",
-            "dev": true
+            "version": "4.12.3",
+            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.3.tgz",
+            "integrity": "sha512-fGTi3gxV/23FTYdAoUtLYp6qySe2KE3teyZitipKNRuVYcBkoP/bB3guXN/XVKUe9mxCHXnc9C4ocyz8OmgN0g==",
+            "dev": true,
+            "license": "MIT"
         },
         "node_modules/boolbase": {
             "version": "1.0.0",
@@ -3500,9 +3575,9 @@
             "dev": true
         },
         "node_modules/brace-expansion": {
-            "version": "1.1.11",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-            "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "dependencies": {
                 "balanced-match": "^1.0.0",
                 "concat-map": "0.0.1"
@@ -3570,60 +3645,75 @@
             }
         },
         "node_modules/browserify-rsa": {
-            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz",
-            "integrity": "sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==",
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.1.tgz",
+            "integrity": "sha512-YBjSAiTqM04ZVei6sXighu679a3SqWORA3qZTEqZImnlkDIFtKc6pNutpjyZ8RJTjQtuYfeetkxM11GwoYXMIQ==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "bn.js": "^5.0.0",
-                "randombytes": "^2.0.1"
+                "bn.js": "^5.2.1",
+                "randombytes": "^2.1.0",
+                "safe-buffer": "^5.2.1"
+            },
+            "engines": {
+                "node": ">= 0.10"
             }
         },
         "node_modules/browserify-rsa/node_modules/bn.js": {
+            "version": "5.2.3",
+            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.3.tgz",
+            "integrity": "sha512-EAcmnPkxpntVL+DS7bO1zhcZNvCkxqtkd0ZY53h06GNQ3DEkkGZ/gKgmDv6DdZQGj9BgfSPKtJJ7Dp1GPP8f7w==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/browserify-rsa/node_modules/safe-buffer": {
             "version": "5.2.1",
-            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz",
-            "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==",
-            "dev": true
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
         },
         "node_modules/browserify-sign": {
-            "version": "4.2.2",
-            "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.2.tgz",
-            "integrity": "sha512-1rudGyeYY42Dk6texmv7c4VcQ0EsvVbLwZkA+AQB7SxvXxmcD93jcHie8bzecJ+ChDlmAm2Qyu0+Ccg5uhZXCg==",
+            "version": "4.2.5",
+            "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.5.tgz",
+            "integrity": "sha512-C2AUdAJg6rlM2W5QMp2Q4KGQMVBwR1lIimTsUnutJ8bMpW5B52pGpR2gEnNBNwijumDo5FojQ0L9JrXA8m4YEw==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
-                "bn.js": "^5.2.1",
-                "browserify-rsa": "^4.1.0",
+                "bn.js": "^5.2.2",
+                "browserify-rsa": "^4.1.1",
                 "create-hash": "^1.2.0",
                 "create-hmac": "^1.1.7",
-                "elliptic": "^6.5.4",
+                "elliptic": "^6.6.1",
                 "inherits": "^2.0.4",
-                "parse-asn1": "^5.1.6",
-                "readable-stream": "^3.6.2",
+                "parse-asn1": "^5.1.9",
+                "readable-stream": "^2.3.8",
                 "safe-buffer": "^5.2.1"
             },
             "engines": {
-                "node": ">= 4"
+                "node": ">= 0.10"
             }
         },
         "node_modules/browserify-sign/node_modules/bn.js": {
-            "version": "5.2.1",
-            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz",
-            "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==",
-            "dev": true
-        },
-        "node_modules/browserify-sign/node_modules/readable-stream": {
-            "version": "3.6.2",
-            "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
-            "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+            "version": "5.2.3",
+            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.3.tgz",
+            "integrity": "sha512-EAcmnPkxpntVL+DS7bO1zhcZNvCkxqtkd0ZY53h06GNQ3DEkkGZ/gKgmDv6DdZQGj9BgfSPKtJJ7Dp1GPP8f7w==",
             "dev": true,
-            "dependencies": {
-                "inherits": "^2.0.3",
-                "string_decoder": "^1.1.1",
-                "util-deprecate": "^1.0.1"
-            },
-            "engines": {
-                "node": ">= 6"
-            }
+            "license": "MIT"
         },
         "node_modules/browserify-sign/node_modules/safe-buffer": {
             "version": "5.2.1",
@@ -3655,9 +3745,9 @@
             }
         },
         "node_modules/browserslist": {
-            "version": "4.23.3",
-            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
-            "integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+            "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
             "dev": true,
             "funding": [
                 {
@@ -3674,10 +3764,11 @@
                 }
             ],
             "dependencies": {
-                "caniuse-lite": "^1.0.30001646",
-                "electron-to-chromium": "^1.5.4",
-                "node-releases": "^2.0.18",
-                "update-browserslist-db": "^1.1.0"
+                "baseline-browser-mapping": "^2.9.0",
+                "caniuse-lite": "^1.0.30001759",
+                "electron-to-chromium": "^1.5.263",
+                "node-releases": "^2.0.27",
+                "update-browserslist-db": "^1.2.0"
             },
             "bin": {
                 "browserslist": "cli.js"
@@ -3826,16 +3917,46 @@
             }
         },
         "node_modules/call-bind": {
-            "version": "1.0.7",
-            "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
-            "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+            "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
+                "call-bind-apply-helpers": "^1.0.0",
                 "es-define-property": "^1.0.0",
-                "es-errors": "^1.3.0",
-                "function-bind": "^1.1.2",
                 "get-intrinsic": "^1.2.4",
-                "set-function-length": "^1.2.1"
+                "set-function-length": "^1.2.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/call-bind-apply-helpers": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+            "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+            "license": "MIT",
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "function-bind": "^1.1.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/call-bound": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+            "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "call-bind-apply-helpers": "^1.0.2",
+                "get-intrinsic": "^1.3.0"
             },
             "engines": {
                 "node": ">= 0.4"
@@ -3864,9 +3985,9 @@
             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001655",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001655.tgz",
-            "integrity": "sha512-jRGVy3iSGO5Uutn2owlb5gR6qsGngTw9ZTb4ali9f3glshcNmJ2noam4Mo9zia5P9Dk3jNNydy7vQjuE5dQmfg==",
+            "version": "1.0.30001768",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001768.tgz",
+            "integrity": "sha512-qY3aDRZC5nWPgHUgIB84WL+nySuo19wk0VJpp/XI9T34lrvkyhRvNVOFJOp2kxClQhiFBu+TaUSudf6oa3vkSA==",
             "dev": true,
             "funding": [
                 {
@@ -4243,15 +4364,41 @@
             }
         },
         "node_modules/cipher-base": {
-            "version": "1.0.4",
-            "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz",
-            "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
+            "version": "1.0.7",
+            "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.7.tgz",
+            "integrity": "sha512-Mz9QMT5fJe7bKI7MH31UilT5cEK5EHHRCccw/YRFsRY47AuNgaV6HY3rscp0/I4Q+tTW/5zoqpSeRRI54TkDWA==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "inherits": "^2.0.1",
-                "safe-buffer": "^5.0.1"
+                "inherits": "^2.0.4",
+                "safe-buffer": "^5.2.1",
+                "to-buffer": "^1.2.2"
+            },
+            "engines": {
+                "node": ">= 0.10"
             }
         },
+        "node_modules/cipher-base/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
+        },
         "node_modules/circular-json": {
             "version": "0.3.3",
             "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz",
@@ -4548,11 +4695,16 @@
             }
         },
         "node_modules/core-js-pure": {
-            "version": "3.1.4",
-            "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.1.4.tgz",
-            "integrity": "sha512-uJ4Z7iPNwiu1foygbcZYJsJs1jiXrTTCvxfLDXNhI/I+NHbSIEyr548y4fcsCEyWY0XgfAG/qqaunJ1SThHenA==",
+            "version": "3.42.0",
+            "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.42.0.tgz",
+            "integrity": "sha512-007bM04u91fF4kMgwom2I5cQxAFIy8jVulgr9eozILl/SZE53QOqnW/+vviC+wQWLv+AunBG+8Q0TLoeSsSxRQ==",
             "dev": true,
-            "hasInstallScript": true
+            "hasInstallScript": true,
+            "license": "MIT",
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/core-js"
+            }
         },
         "node_modules/core-util-is": {
             "version": "1.0.2",
@@ -4561,13 +4713,14 @@
             "dev": true
         },
         "node_modules/create-ecdh": {
-            "version": "4.0.3",
-            "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz",
-            "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.4.tgz",
+            "integrity": "sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
                 "bn.js": "^4.1.0",
-                "elliptic": "^6.0.0"
+                "elliptic": "^6.5.3"
             }
         },
         "node_modules/create-hash": {
@@ -4714,25 +4867,30 @@
             }
         },
         "node_modules/crypto-browserify": {
-            "version": "3.12.0",
-            "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz",
-            "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==",
+            "version": "3.12.1",
+            "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.1.tgz",
+            "integrity": "sha512-r4ESw/IlusD17lgQi1O20Fa3qNnsckR126TdUuBgAu7GBYSIPvdNyONd3Zrxh0xCwA4+6w/TDArBPsMvhur+KQ==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "browserify-cipher": "^1.0.0",
-                "browserify-sign": "^4.0.0",
-                "create-ecdh": "^4.0.0",
-                "create-hash": "^1.1.0",
-                "create-hmac": "^1.1.0",
-                "diffie-hellman": "^5.0.0",
-                "inherits": "^2.0.1",
-                "pbkdf2": "^3.0.3",
-                "public-encrypt": "^4.0.0",
-                "randombytes": "^2.0.0",
-                "randomfill": "^1.0.3"
+                "browserify-cipher": "^1.0.1",
+                "browserify-sign": "^4.2.3",
+                "create-ecdh": "^4.0.4",
+                "create-hash": "^1.2.0",
+                "create-hmac": "^1.1.7",
+                "diffie-hellman": "^5.0.3",
+                "hash-base": "~3.0.4",
+                "inherits": "^2.0.4",
+                "pbkdf2": "^3.1.2",
+                "public-encrypt": "^4.0.3",
+                "randombytes": "^2.1.0",
+                "randomfill": "^1.0.4"
             },
             "engines": {
-                "node": "*"
+                "node": ">= 0.10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
             }
         },
         "node_modules/damerau-levenshtein": {
@@ -5187,10 +5345,11 @@
             }
         },
         "node_modules/diff": {
-            "version": "4.0.2",
-            "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-            "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.4.tgz",
+            "integrity": "sha512-X07nttJQkwkfKfvTPG/KSnE2OMdcUCao6+eXF3wmnIQRn2aPAHH3VxDbDOdegkd6JbPsXqShpvEOHfAT+nCNwQ==",
             "dev": true,
+            "license": "BSD-3-Clause",
             "engines": {
                 "node": ">=0.3.1"
             }
@@ -5287,6 +5446,20 @@
                 "semver": "bin/semver"
             }
         },
+        "node_modules/dunder-proto": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+            "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+            "license": "MIT",
+            "dependencies": {
+                "call-bind-apply-helpers": "^1.0.1",
+                "es-errors": "^1.3.0",
+                "gopd": "^1.2.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
         "node_modules/duplexer": {
             "version": "0.1.2",
             "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz",
@@ -5351,9 +5524,9 @@
             }
         },
         "node_modules/electron-to-chromium": {
-            "version": "1.5.13",
-            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.13.tgz",
-            "integrity": "sha512-lbBcvtIJ4J6sS4tb5TLp1b4LyfCdMkwStzXPyAgVgTRAsep4bvrAGaBOP7ZJtQMNJpSQ9SqG4brWOroNaQtm7Q==",
+            "version": "1.5.286",
+            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
+            "integrity": "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A==",
             "dev": true
         },
         "node_modules/elliptic": {
@@ -5372,12 +5545,6 @@
                 "minimalistic-crypto-utils": "^1.0.1"
             }
         },
-        "node_modules/elliptic/node_modules/bn.js": {
-            "version": "4.12.0",
-            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
-            "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
-            "dev": true
-        },
         "node_modules/emitter-listener": {
             "version": "1.1.2",
             "resolved": "https://registry.npmjs.org/emitter-listener/-/emitter-listener-1.1.2.tgz",
@@ -5411,13 +5578,13 @@
             }
         },
         "node_modules/enhanced-resolve": {
-            "version": "5.17.1",
-            "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz",
-            "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==",
+            "version": "5.19.0",
+            "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz",
+            "integrity": "sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==",
             "dev": true,
             "dependencies": {
                 "graceful-fs": "^4.2.4",
-                "tapable": "^2.2.0"
+                "tapable": "^2.3.0"
             },
             "engines": {
                 "node": ">=10.13.0"
@@ -5505,13 +5672,10 @@
             }
         },
         "node_modules/es-define-property": {
-            "version": "1.0.0",
-            "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
-            "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
-            "dev": true,
-            "dependencies": {
-                "get-intrinsic": "^1.2.4"
-            },
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+            "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+            "license": "MIT",
             "engines": {
                 "node": ">= 0.4"
             }
@@ -5520,22 +5684,21 @@
             "version": "1.3.0",
             "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
             "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-            "dev": true,
             "engines": {
                 "node": ">= 0.4"
             }
         },
         "node_modules/es-module-lexer": {
-            "version": "1.5.4",
-            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.5.4.tgz",
-            "integrity": "sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw==",
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.0.0.tgz",
+            "integrity": "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==",
             "dev": true
         },
         "node_modules/es-object-atoms": {
-            "version": "1.0.0",
-            "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
-            "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
-            "dev": true,
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+            "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+            "license": "MIT",
             "dependencies": {
                 "es-errors": "^1.3.0"
             },
@@ -5544,14 +5707,14 @@
             }
         },
         "node_modules/es-set-tostringtag": {
-            "version": "2.0.3",
-            "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.3.tgz",
-            "integrity": "sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==",
-            "dev": true,
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+            "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
             "dependencies": {
-                "get-intrinsic": "^1.2.4",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.6",
                 "has-tostringtag": "^1.0.2",
-                "hasown": "^2.0.1"
+                "hasown": "^2.0.2"
             },
             "engines": {
                 "node": ">= 0.4"
@@ -5774,10 +5937,11 @@
             }
         },
         "node_modules/eslint-plugin-import/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -5840,10 +6004,11 @@
             "dev": true
         },
         "node_modules/eslint-plugin-jsx-a11y/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -5911,10 +6076,11 @@
             }
         },
         "node_modules/eslint-plugin-react/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -6166,11 +6332,10 @@
             }
         },
         "node_modules/eslint/node_modules/js-yaml": {
-            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-            "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+            "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
             "dev": true,
-            "license": "MIT",
             "dependencies": {
                 "argparse": "^2.0.1"
             },
@@ -6195,10 +6360,11 @@
             }
         },
         "node_modules/eslint/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -6632,6 +6798,22 @@
             "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
             "dev": true
         },
+        "node_modules/fast-uri": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
+            "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/fastify"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/fastify"
+                }
+            ]
+        },
         "node_modules/fastest-levenshtein": {
             "version": "1.0.12",
             "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.12.tgz",
@@ -6826,9 +7008,9 @@
             }
         },
         "node_modules/flatted": {
-            "version": "3.2.4",
-            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.4.tgz",
-            "integrity": "sha512-8/sOawo8tJ4QOBX8YlQBMxL8+RLZfxMQOif9o0KUKTNTjMYElWPE0r/m5VNFxTRd0NSw8qSy8dajrwX4RYI1Hw==",
+            "version": "3.4.2",
+            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+            "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
             "dev": true
         },
         "node_modules/flush-write-stream": {
@@ -6842,12 +7024,19 @@
             }
         },
         "node_modules/for-each": {
-            "version": "0.3.3",
-            "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
-            "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
+            "version": "0.3.5",
+            "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+            "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "is-callable": "^1.1.3"
+                "is-callable": "^1.2.7"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
             }
         },
         "node_modules/for-in": {
@@ -6930,12 +7119,14 @@
             }
         },
         "node_modules/form-data": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
-            "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+            "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
             "dependencies": {
                 "asynckit": "^0.4.0",
                 "combined-stream": "^1.0.8",
+                "es-set-tostringtag": "^2.1.0",
+                "hasown": "^2.0.2",
                 "mime-types": "^2.1.12"
             },
             "engines": {
@@ -7101,16 +7292,21 @@
             }
         },
         "node_modules/get-intrinsic": {
-            "version": "1.2.4",
-            "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
-            "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
-            "dev": true,
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+            "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+            "license": "MIT",
             "dependencies": {
+                "call-bind-apply-helpers": "^1.0.2",
+                "es-define-property": "^1.0.1",
                 "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.1.1",
                 "function-bind": "^1.1.2",
-                "has-proto": "^1.0.1",
-                "has-symbols": "^1.0.3",
-                "hasown": "^2.0.0"
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
+                "has-symbols": "^1.1.0",
+                "hasown": "^2.0.2",
+                "math-intrinsics": "^1.1.0"
             },
             "engines": {
                 "node": ">= 0.4"
@@ -7140,6 +7336,19 @@
                 "url": "https://github.com/sponsors/sindresorhus"
             }
         },
+        "node_modules/get-proto": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+            "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+            "license": "MIT",
+            "dependencies": {
+                "dunder-proto": "^1.0.1",
+                "es-object-atoms": "^1.0.0"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
         "node_modules/get-stream": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
@@ -7270,9 +7479,10 @@
             }
         },
         "node_modules/glob/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -7380,12 +7590,12 @@
             }
         },
         "node_modules/gopd": {
-            "version": "1.0.1",
-            "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
-            "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
-            "dev": true,
-            "dependencies": {
-                "get-intrinsic": "^1.1.3"
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+            "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
             },
             "funding": {
                 "url": "https://github.com/sponsors/ljharb"
@@ -7903,10 +8113,10 @@
             }
         },
         "node_modules/has-symbols": {
-            "version": "1.0.3",
-            "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
-            "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
-            "dev": true,
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+            "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+            "license": "MIT",
             "engines": {
                 "node": ">= 0.4"
             },
@@ -7931,7 +8141,6 @@
             "version": "1.0.2",
             "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
             "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-            "dev": true,
             "dependencies": {
                 "has-symbols": "^1.0.3"
             },
@@ -8720,12 +8929,13 @@
             }
         },
         "node_modules/is-typed-array": {
-            "version": "1.1.13",
-            "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz",
-            "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==",
+            "version": "1.1.15",
+            "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+            "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "which-typed-array": "^1.1.14"
+                "which-typed-array": "^1.1.16"
             },
             "engines": {
                 "node": ">= 0.4"
@@ -8951,6 +9161,15 @@
                 "node": ">=8"
             }
         },
+        "node_modules/istanbul-lib-processinfo/node_modules/uuid": {
+            "version": "8.3.2",
+            "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+            "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+            "dev": true,
+            "bin": {
+                "uuid": "dist/bin/uuid"
+            }
+        },
         "node_modules/istanbul-lib-report": {
             "version": "3.0.0",
             "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz",
@@ -9105,9 +9324,9 @@
             "dev": true
         },
         "node_modules/js-yaml": {
-            "version": "3.13.1",
-            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz",
-            "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==",
+            "version": "3.14.2",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
+            "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
             "dev": true,
             "dependencies": {
                 "argparse": "^1.0.7",
@@ -9207,23 +9426,23 @@
             }
         },
         "node_modules/jsonwebtoken/node_modules/jwa": {
-            "version": "1.4.1",
-            "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.1.tgz",
-            "integrity": "sha512-qiLX/xhEEFKUAJ6FiBMbes3w9ATzyk5W7Hvzpa/SLYdxNtng+gcurvrI7TbACjIXlsJyr05/S1oUhZrc63evQA==",
+            "version": "1.4.2",
+            "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.2.tgz",
+            "integrity": "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==",
             "dev": true,
             "dependencies": {
-                "buffer-equal-constant-time": "1.0.1",
+                "buffer-equal-constant-time": "^1.0.1",
                 "ecdsa-sig-formatter": "1.0.11",
                 "safe-buffer": "^5.0.1"
             }
         },
         "node_modules/jsonwebtoken/node_modules/jws": {
-            "version": "3.2.2",
-            "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz",
-            "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==",
+            "version": "3.2.3",
+            "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.3.tgz",
+            "integrity": "sha512-byiJ0FLRdLdSVSReO/U4E7RoEyOCKnEnEPMjq3HxWtvzLsV08/i5RQKsFVNkCldrCaPr2vDNAOMsfs8T/Hze7g==",
             "dev": true,
             "dependencies": {
-                "jwa": "^1.4.1",
+                "jwa": "^1.4.2",
                 "safe-buffer": "^5.0.1"
             }
         },
@@ -9259,23 +9478,23 @@
             "dev": true
         },
         "node_modules/jwa": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
-            "integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+            "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
             "dev": true,
             "dependencies": {
-                "buffer-equal-constant-time": "1.0.1",
+                "buffer-equal-constant-time": "^1.0.1",
                 "ecdsa-sig-formatter": "1.0.11",
                 "safe-buffer": "^5.0.1"
             }
         },
         "node_modules/jws": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
-            "integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
+            "version": "4.0.1",
+            "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
+            "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
             "dev": true,
             "dependencies": {
-                "jwa": "^2.0.0",
+                "jwa": "^2.0.1",
                 "safe-buffer": "^5.0.1"
             }
         },
@@ -9426,12 +9645,16 @@
             }
         },
         "node_modules/loader-runner": {
-            "version": "4.2.0",
-            "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.2.0.tgz",
-            "integrity": "sha512-92+huvxMvYlMzMt0iIOukcwYBFpkYJdpl2xsZ7LrlayO7E8SOv+JJUEK17B/dJIHAOLMfh2dZZ/Y18WgmGtYNw==",
+            "version": "4.3.1",
+            "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.1.tgz",
+            "integrity": "sha512-IWqP2SCPhyVFTBtRcgMHdzlf9ul25NwaFx4wCEH/KjAXuuHY4yNjvPXsBokp8jCB936PyWRaPKUNh8NvylLp2Q==",
             "dev": true,
             "engines": {
                 "node": ">=6.11.5"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/webpack"
             }
         },
         "node_modules/loader-utils": {
@@ -9461,15 +9684,9 @@
             }
         },
         "node_modules/lodash": {
-            "version": "4.17.21",
-            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-            "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
-        },
-        "node_modules/lodash._reinterpolate": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz",
-            "integrity": "sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=",
-            "dev": true
+            "version": "4.18.1",
+            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+            "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q=="
         },
         "node_modules/lodash.flattendeep": {
             "version": "4.4.0",
@@ -9531,31 +9748,6 @@
             "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
             "dev": true
         },
-        "node_modules/lodash.some": {
-            "version": "4.6.0",
-            "resolved": "https://registry.npmjs.org/lodash.some/-/lodash.some-4.6.0.tgz",
-            "integrity": "sha1-G7nzFO9ri63tE7VJFpsqlF62jk0=",
-            "dev": true
-        },
-        "node_modules/lodash.template": {
-            "version": "4.5.0",
-            "resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz",
-            "integrity": "sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==",
-            "dev": true,
-            "dependencies": {
-                "lodash._reinterpolate": "^3.0.0",
-                "lodash.templatesettings": "^4.0.0"
-            }
-        },
-        "node_modules/lodash.templatesettings": {
-            "version": "4.2.0",
-            "resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz",
-            "integrity": "sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==",
-            "dev": true,
-            "dependencies": {
-                "lodash._reinterpolate": "^3.0.0"
-            }
-        },
         "node_modules/log-symbols": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
@@ -9745,6 +9937,15 @@
             "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
             "dev": true
         },
+        "node_modules/math-intrinsics": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+            "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
         "node_modules/md5": {
             "version": "2.3.0",
             "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz",
@@ -9876,9 +10077,9 @@
             "dev": true
         },
         "node_modules/minimatch": {
-            "version": "5.1.0",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.0.tgz",
-            "integrity": "sha512-9TPBGGak4nHfGZsPBohm9AWg6NoT7QTCehS3BIJABslyZbzxfV78QM2Y6+i741OPZIafFAaiiEMh5OyIrJPgtg==",
+            "version": "5.1.8",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.8.tgz",
+            "integrity": "sha512-7RN35vit8DeBclkofOVmBY0eDAZZQd1HzmukRdSyz95CRh8FT54eqnbj0krQr3mrHR6sfRyYkyhwBWjoV5uqlQ==",
             "dependencies": {
                 "brace-expansion": "^2.0.1"
             },
@@ -9887,9 +10088,9 @@
             }
         },
         "node_modules/minimatch/node_modules/brace-expansion": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-            "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+            "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
             "dependencies": {
                 "balanced-match": "^1.0.0"
             }
@@ -9930,29 +10131,30 @@
             "optional": true
         },
         "node_modules/mocha": {
-            "version": "11.1.0",
-            "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
-            "integrity": "sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==",
+            "version": "11.7.5",
+            "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.7.5.tgz",
+            "integrity": "sha512-mTT6RgopEYABzXWFx+GcJ+ZQ32kp4fMf0xvpZIIfSq9Z8lC/++MtcCnQ9t5FP2veYEP95FIYSvW+U9fV4xrlig==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
-                "ansi-colors": "^4.1.3",
                 "browser-stdout": "^1.3.1",
-                "chokidar": "^3.5.3",
+                "chokidar": "^4.0.1",
                 "debug": "^4.3.5",
-                "diff": "^5.2.0",
+                "diff": "^7.0.0",
                 "escape-string-regexp": "^4.0.0",
                 "find-up": "^5.0.0",
                 "glob": "^10.4.5",
                 "he": "^1.2.0",
+                "is-path-inside": "^3.0.3",
                 "js-yaml": "^4.1.0",
                 "log-symbols": "^4.1.0",
-                "minimatch": "^5.1.6",
+                "minimatch": "^9.0.5",
                 "ms": "^2.1.3",
+                "picocolors": "^1.1.1",
                 "serialize-javascript": "^6.0.2",
                 "strip-json-comments": "^3.1.1",
                 "supports-color": "^8.1.1",
-                "workerpool": "^6.5.1",
+                "workerpool": "^9.2.0",
                 "yargs": "^17.7.2",
                 "yargs-parser": "^21.1.1",
                 "yargs-unparser": "^2.0.0"
@@ -10014,16 +10216,6 @@
                 }
             }
         },
-        "node_modules/mocha/node_modules/ansi-colors": {
-            "version": "4.1.3",
-            "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
-            "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=6"
-            }
-        },
         "node_modules/mocha/node_modules/argparse": {
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
@@ -10031,15 +10223,30 @@
             "dev": true
         },
         "node_modules/mocha/node_modules/brace-expansion": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-            "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+            "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
             "dev": true,
-            "license": "MIT",
             "dependencies": {
                 "balanced-match": "^1.0.0"
             }
         },
+        "node_modules/mocha/node_modules/chokidar": {
+            "version": "4.0.3",
+            "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+            "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "readdirp": "^4.0.1"
+            },
+            "engines": {
+                "node": ">= 14.16.0"
+            },
+            "funding": {
+                "url": "https://paulmillr.com/funding/"
+            }
+        },
         "node_modules/mocha/node_modules/cliui": {
             "version": "8.0.1",
             "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
@@ -10089,9 +10296,9 @@
             }
         },
         "node_modules/mocha/node_modules/diff": {
-            "version": "5.2.0",
-            "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
-            "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
+            "version": "7.0.0",
+            "resolved": "https://registry.npmjs.org/diff/-/diff-7.0.0.tgz",
+            "integrity": "sha512-PJWHUb1RFevKCwaFA9RlG5tCd+FO5iRh9A8HEtkmBH2Li03iJriB6m6JIN4rGz3K3JLawI7/veA1xzRKP6ISBw==",
             "dev": true,
             "license": "BSD-3-Clause",
             "engines": {
@@ -10144,9 +10351,10 @@
             }
         },
         "node_modules/mocha/node_modules/glob": {
-            "version": "10.4.5",
-            "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-            "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+            "version": "10.5.0",
+            "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+            "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+            "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
             "dev": true,
             "license": "ISC",
             "dependencies": {
@@ -10164,22 +10372,6 @@
                 "url": "https://github.com/sponsors/isaacs"
             }
         },
-        "node_modules/mocha/node_modules/glob/node_modules/minimatch": {
-            "version": "9.0.5",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-            "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-            "dev": true,
-            "license": "ISC",
-            "dependencies": {
-                "brace-expansion": "^2.0.1"
-            },
-            "engines": {
-                "node": ">=16 || 14 >=14.17"
-            },
-            "funding": {
-                "url": "https://github.com/sponsors/isaacs"
-            }
-        },
         "node_modules/mocha/node_modules/has-flag": {
             "version": "4.0.0",
             "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -10190,9 +10382,9 @@
             }
         },
         "node_modules/mocha/node_modules/js-yaml": {
-            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-            "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+            "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
             "dev": true,
             "dependencies": {
                 "argparse": "^2.0.1"
@@ -10217,16 +10409,19 @@
             }
         },
         "node_modules/mocha/node_modules/minimatch": {
-            "version": "5.1.6",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-            "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+            "version": "9.0.9",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+            "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
             "dev": true,
             "license": "ISC",
             "dependencies": {
-                "brace-expansion": "^2.0.1"
+                "brace-expansion": "^2.0.2"
             },
             "engines": {
-                "node": ">=10"
+                "node": ">=16 || 14 >=14.17"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/isaacs"
             }
         },
         "node_modules/mocha/node_modules/ms": {
@@ -10275,6 +10470,20 @@
                 "node": ">=8"
             }
         },
+        "node_modules/mocha/node_modules/readdirp": {
+            "version": "4.1.2",
+            "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+            "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 14.18.0"
+            },
+            "funding": {
+                "type": "individual",
+                "url": "https://paulmillr.com/funding/"
+            }
+        },
         "node_modules/mocha/node_modules/shebang-command": {
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -10723,9 +10932,9 @@
             }
         },
         "node_modules/node-releases": {
-            "version": "2.0.18",
-            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
-            "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
+            "version": "2.0.27",
+            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+            "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
             "dev": true
         },
         "node_modules/node-stream-zip": {
@@ -10872,10 +11081,13 @@
             }
         },
         "node_modules/object-inspect": {
-            "version": "1.13.1",
-            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz",
-            "integrity": "sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==",
+            "version": "1.13.4",
+            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+            "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
             "dev": true,
+            "engines": {
+                "node": ">= 0.4"
+            },
             "funding": {
                 "url": "https://github.com/sponsors/ljharb"
             }
@@ -11107,14 +11319,6 @@
             "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=",
             "dev": true
         },
-        "node_modules/os-tmpdir": {
-            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-            "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=",
-            "engines": {
-                "node": ">=0.10.0"
-            }
-        },
         "node_modules/p-cancelable": {
             "version": "0.4.1",
             "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.4.1.tgz",
@@ -11264,18 +11468,43 @@
             }
         },
         "node_modules/parse-asn1": {
-            "version": "5.1.6",
-            "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.6.tgz",
-            "integrity": "sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==",
+            "version": "5.1.9",
+            "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.9.tgz",
+            "integrity": "sha512-fIYNuZ/HastSb80baGOuPRo1O9cf4baWw5WsAp7dBuUzeTD/BoaG8sVTdlPFksBE2lF21dN+A1AnrpIjSWqHHg==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
-                "asn1.js": "^5.2.0",
-                "browserify-aes": "^1.0.0",
-                "evp_bytestokey": "^1.0.0",
-                "pbkdf2": "^3.0.3",
-                "safe-buffer": "^5.1.1"
+                "asn1.js": "^4.10.1",
+                "browserify-aes": "^1.2.0",
+                "evp_bytestokey": "^1.0.3",
+                "pbkdf2": "^3.1.5",
+                "safe-buffer": "^5.2.1"
+            },
+            "engines": {
+                "node": ">= 0.10"
             }
         },
+        "node_modules/parse-asn1/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
+        },
         "node_modules/parse-filepath": {
             "version": "1.0.2",
             "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz",
@@ -11446,21 +11675,44 @@
             }
         },
         "node_modules/pbkdf2": {
-            "version": "3.0.17",
-            "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz",
-            "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.5.tgz",
+            "integrity": "sha512-Q3CG/cYvCO1ye4QKkuH7EXxs3VC/rI1/trd+qX2+PolbaKG0H+bgcZzrTt96mMyRtejk+JMCiLUn3y29W8qmFQ==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "create-hash": "^1.1.2",
-                "create-hmac": "^1.1.4",
-                "ripemd160": "^2.0.1",
-                "safe-buffer": "^5.0.1",
-                "sha.js": "^2.4.8"
+                "create-hash": "^1.2.0",
+                "create-hmac": "^1.1.7",
+                "ripemd160": "^2.0.3",
+                "safe-buffer": "^5.2.1",
+                "sha.js": "^2.4.12",
+                "to-buffer": "^1.2.1"
             },
             "engines": {
-                "node": ">=0.12"
+                "node": ">= 0.10"
             }
         },
+        "node_modules/pbkdf2/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
+        },
         "node_modules/pend": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
@@ -11468,15 +11720,16 @@
             "dev": true
         },
         "node_modules/picocolors": {
-            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-            "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
-            "dev": true
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+            "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+            "dev": true,
+            "license": "ISC"
         },
         "node_modules/picomatch": {
-            "version": "2.3.1",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-            "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+            "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
             "dev": true,
             "engines": {
                 "node": ">=8.6"
@@ -11717,12 +11970,12 @@
             }
         },
         "node_modules/qs": {
-            "version": "6.12.1",
-            "resolved": "https://registry.npmjs.org/qs/-/qs-6.12.1.tgz",
-            "integrity": "sha512-zWmv4RSuB9r2mYQw3zxQuHWeU+42aKi1wWig/j4ele4ygELZ7PEO6MM7rim9oAQH2A5MWfsAVf/jPvTPgCbvUQ==",
+            "version": "6.15.0",
+            "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.0.tgz",
+            "integrity": "sha512-mAZTtNCeetKMH+pSjrb76NAM8V9a05I9aBZOHztWy/UqcJdQYNsf59vrRKWnojAT9Y+GbIvoTBC++CPHqpDBhQ==",
             "dev": true,
             "dependencies": {
-                "side-channel": "^1.0.6"
+                "side-channel": "^1.1.0"
             },
             "engines": {
                 "node": ">=0.6"
@@ -11855,10 +12108,11 @@
             }
         },
         "node_modules/readable-stream": {
-            "version": "2.3.7",
-            "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
-            "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
+            "version": "2.3.8",
+            "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+            "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
                 "core-util-is": "~1.0.0",
                 "inherits": "~2.0.3",
@@ -11908,12 +12162,6 @@
             "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
             "license": "Apache-2.0"
         },
-        "node_modules/regenerator-runtime": {
-            "version": "0.13.9",
-            "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz",
-            "integrity": "sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==",
-            "dev": true
-        },
         "node_modules/regexp.prototype.flags": {
             "version": "1.5.2",
             "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz",
@@ -12004,6 +12252,15 @@
                 "node": ">=0.10.0"
             }
         },
+        "node_modules/require-from-string": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+            "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+            "dev": true,
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
         "node_modules/require-in-the-middle": {
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/require-in-the-middle/-/require-in-the-middle-7.2.0.tgz",
@@ -12116,15 +12373,14 @@
             }
         },
         "node_modules/rewiremock": {
-            "version": "3.14.5",
-            "resolved": "https://registry.npmjs.org/rewiremock/-/rewiremock-3.14.5.tgz",
-            "integrity": "sha512-MdPutvaUd+kKVz/lcEz6N6337s4PxRUR5vhphIp2/TJRgfXIckomIkCsIAbwB53MjiSLwi7KBMdQ9lPWE5WpYA==",
+            "version": "3.14.6",
+            "resolved": "https://registry.npmjs.org/rewiremock/-/rewiremock-3.14.6.tgz",
+            "integrity": "sha512-hjpS7iQUTVVh/IHV4GE1ypg4IzlgVc34gxZBarwwVrKfnjlyqHJuQdsia6Ac7m4f4k/zxxA3tX285MOstdysRQ==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
                 "babel-runtime": "^6.26.0",
                 "compare-module-exports": "^2.1.0",
-                "lodash.some": "^4.6.0",
-                "lodash.template": "^4.4.0",
                 "node-libs-browser": "^2.1.0",
                 "path-parse": "^1.0.5",
                 "wipe-node-cache": "^2.1.2",
@@ -12147,15 +12403,56 @@
             }
         },
         "node_modules/ripemd160": {
-            "version": "2.0.2",
-            "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz",
-            "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.3.tgz",
+            "integrity": "sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "hash-base": "^3.0.0",
-                "inherits": "^2.0.1"
+                "hash-base": "^3.1.2",
+                "inherits": "^2.0.4"
+            },
+            "engines": {
+                "node": ">= 0.8"
             }
         },
+        "node_modules/ripemd160/node_modules/hash-base": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.2.tgz",
+            "integrity": "sha512-Bb33KbowVTIj5s7Ked1OsqHUeCpz//tPwR+E2zJgJKo9Z5XolZ9b6bdUgjmYlwnWhoOQKoTd1TYToZGn5mAYOg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "inherits": "^2.0.4",
+                "readable-stream": "^2.3.8",
+                "safe-buffer": "^5.2.1",
+                "to-buffer": "^1.2.1"
+            },
+            "engines": {
+                "node": ">= 0.8"
+            }
+        },
+        "node_modules/ripemd160/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
+        },
         "node_modules/run-parallel": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -12365,18 +12662,45 @@
             "dev": true
         },
         "node_modules/sha.js": {
-            "version": "2.4.11",
-            "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz",
-            "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
+            "version": "2.4.12",
+            "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.12.tgz",
+            "integrity": "sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==",
             "dev": true,
             "dependencies": {
-                "inherits": "^2.0.1",
-                "safe-buffer": "^5.0.1"
+                "inherits": "^2.0.4",
+                "safe-buffer": "^5.2.1",
+                "to-buffer": "^1.2.0"
             },
             "bin": {
                 "sha.js": "bin.js"
+            },
+            "engines": {
+                "node": ">= 0.10"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
             }
         },
+        "node_modules/sha.js/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ]
+        },
         "node_modules/shallow-clone": {
             "version": "3.0.1",
             "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz",
@@ -12426,15 +12750,69 @@
             }
         },
         "node_modules/side-channel": {
-            "version": "1.0.6",
-            "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
-            "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+            "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
             "dev": true,
             "dependencies": {
-                "call-bind": "^1.0.7",
                 "es-errors": "^1.3.0",
-                "get-intrinsic": "^1.2.4",
-                "object-inspect": "^1.13.1"
+                "object-inspect": "^1.13.3",
+                "side-channel-list": "^1.0.0",
+                "side-channel-map": "^1.0.1",
+                "side-channel-weakmap": "^1.0.2"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/side-channel-list": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+            "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+            "dev": true,
+            "dependencies": {
+                "es-errors": "^1.3.0",
+                "object-inspect": "^1.13.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/side-channel-map": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+            "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+            "dev": true,
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.5",
+                "object-inspect": "^1.13.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/side-channel-weakmap": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+            "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+            "dev": true,
+            "dependencies": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.5",
+                "object-inspect": "^1.13.3",
+                "side-channel-map": "^1.0.1"
             },
             "engines": {
                 "node": ">= 0.4"
@@ -12544,10 +12922,11 @@
             }
         },
         "node_modules/sinon/node_modules/diff": {
-            "version": "5.2.0",
-            "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
-            "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
+            "version": "5.2.2",
+            "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.2.tgz",
+            "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
             "dev": true,
+            "license": "BSD-3-Clause",
             "engines": {
                 "node": ">=0.3.1"
             }
@@ -13022,18 +13401,22 @@
             }
         },
         "node_modules/tapable": {
-            "version": "2.2.1",
-            "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
-            "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
+            "version": "2.3.0",
+            "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz",
+            "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==",
             "dev": true,
             "engines": {
                 "node": ">=6"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/webpack"
             }
         },
         "node_modules/tar-fs": {
-            "version": "2.1.1",
-            "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.1.tgz",
-            "integrity": "sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==",
+            "version": "2.1.4",
+            "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+            "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
             "dev": true,
             "optional": true,
             "dependencies": {
@@ -13132,13 +13515,13 @@
             }
         },
         "node_modules/terser": {
-            "version": "5.31.6",
-            "resolved": "https://registry.npmjs.org/terser/-/terser-5.31.6.tgz",
-            "integrity": "sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==",
+            "version": "5.46.0",
+            "resolved": "https://registry.npmjs.org/terser/-/terser-5.46.0.tgz",
+            "integrity": "sha512-jTwoImyr/QbOWFFso3YoU3ik0jBBDJ6JTOQiy/J2YxVJdZCc+5u7skhNwiOR3FQIygFqVUPHl7qbbxtjW2K3Qg==",
             "dev": true,
             "dependencies": {
                 "@jridgewell/source-map": "^0.3.3",
-                "acorn": "^8.8.2",
+                "acorn": "^8.15.0",
                 "commander": "^2.20.0",
                 "source-map-support": "~0.5.20"
             },
@@ -13150,16 +13533,16 @@
             }
         },
         "node_modules/terser-webpack-plugin": {
-            "version": "5.3.10",
-            "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
-            "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
+            "version": "5.3.17",
+            "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.17.tgz",
+            "integrity": "sha512-YR7PtUp6GMU91BgSJmlaX/rS2lGDbAF7D+Wtq7hRO+MiljNmodYvqslzCFiYVAgW+Qoaaia/QUIP4lGXufjdZw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "@jridgewell/trace-mapping": "^0.3.20",
+                "@jridgewell/trace-mapping": "^0.3.25",
                 "jest-worker": "^27.4.5",
-                "schema-utils": "^3.1.1",
-                "serialize-javascript": "^6.0.1",
-                "terser": "^5.26.0"
+                "schema-utils": "^4.3.0",
+                "terser": "^5.31.1"
             },
             "engines": {
                 "node": ">= 10.13.0"
@@ -13183,6 +13566,60 @@
                 }
             }
         },
+        "node_modules/terser-webpack-plugin/node_modules/ajv": {
+            "version": "8.18.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+            "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3",
+                "fast-uri": "^3.0.1",
+                "json-schema-traverse": "^1.0.0",
+                "require-from-string": "^2.0.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/terser-webpack-plugin/node_modules/ajv-keywords": {
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+            "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+            "dev": true,
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3"
+            },
+            "peerDependencies": {
+                "ajv": "^8.8.2"
+            }
+        },
+        "node_modules/terser-webpack-plugin/node_modules/json-schema-traverse": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+            "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+            "dev": true
+        },
+        "node_modules/terser-webpack-plugin/node_modules/schema-utils": {
+            "version": "4.3.3",
+            "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz",
+            "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
+            "dev": true,
+            "dependencies": {
+                "@types/json-schema": "^7.0.9",
+                "ajv": "^8.9.0",
+                "ajv-formats": "^2.1.1",
+                "ajv-keywords": "^5.1.0"
+            },
+            "engines": {
+                "node": ">= 10.13.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/webpack"
+            }
+        },
         "node_modules/test-exclude": {
             "version": "6.0.0",
             "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz",
@@ -13198,10 +13635,11 @@
             }
         },
         "node_modules/test-exclude/node_modules/minimatch": {
-            "version": "3.1.2",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-            "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+            "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
             "dev": true,
+            "license": "ISC",
             "dependencies": {
                 "brace-expansion": "^1.1.7"
             },
@@ -13274,14 +13712,12 @@
             }
         },
         "node_modules/tmp": {
-            "version": "0.0.33",
-            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-            "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-            "dependencies": {
-                "os-tmpdir": "~1.0.2"
-            },
+            "version": "0.2.5",
+            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
+            "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==",
+            "license": "MIT",
             "engines": {
-                "node": ">=0.6.0"
+                "node": ">=14.14"
             }
         },
         "node_modules/to-absolute-glob": {
@@ -13304,20 +13740,47 @@
             "dev": true
         },
         "node_modules/to-buffer": {
-            "version": "1.1.1",
-            "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.1.1.tgz",
-            "integrity": "sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==",
+            "version": "1.2.2",
+            "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.2.tgz",
+            "integrity": "sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "isarray": "^2.0.5",
+                "safe-buffer": "^5.2.1",
+                "typed-array-buffer": "^1.0.3"
+            },
+            "engines": {
+                "node": ">= 0.4"
+            }
+        },
+        "node_modules/to-buffer/node_modules/isarray": {
+            "version": "2.0.5",
+            "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+            "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
             "dev": true,
             "license": "MIT"
         },
-        "node_modules/to-fast-properties": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
-            "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==",
+        "node_modules/to-buffer/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
             "dev": true,
-            "engines": {
-                "node": ">=4"
-            }
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
         },
         "node_modules/to-regex-range": {
             "version": "5.0.1",
@@ -13696,14 +14159,15 @@
             }
         },
         "node_modules/typed-array-buffer": {
-            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz",
-            "integrity": "sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==",
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+            "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
-                "call-bind": "^1.0.7",
+                "call-bound": "^1.0.3",
                 "es-errors": "^1.3.0",
-                "is-typed-array": "^1.1.13"
+                "is-typed-array": "^1.1.14"
             },
             "engines": {
                 "node": ">= 0.4"
@@ -13902,10 +14366,11 @@
             }
         },
         "node_modules/undici-types": {
-            "version": "6.19.8",
-            "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
-            "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
-            "dev": true
+            "version": "6.21.0",
+            "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+            "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+            "dev": true,
+            "license": "MIT"
         },
         "node_modules/unicode": {
             "version": "14.0.0",
@@ -13926,9 +14391,9 @@
             }
         },
         "node_modules/update-browserslist-db": {
-            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
-            "integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+            "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
             "dev": true,
             "funding": [
                 {
@@ -13945,8 +14410,8 @@
                 }
             ],
             "dependencies": {
-                "escalade": "^3.1.2",
-                "picocolors": "^1.0.1"
+                "escalade": "^3.2.0",
+                "picocolors": "^1.1.1"
             },
             "bin": {
                 "update-browserslist-db": "cli.js"
@@ -14031,11 +14496,16 @@
             "dev": true
         },
         "node_modules/uuid": {
-            "version": "8.3.2",
-            "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-            "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+            "version": "14.0.0",
+            "resolved": "https://registry.npmjs.org/uuid/-/uuid-14.0.0.tgz",
+            "integrity": "sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==",
+            "dev": true,
+            "funding": [
+                "https://github.com/sponsors/broofa",
+                "https://github.com/sponsors/ctavan"
+            ],
             "bin": {
-                "uuid": "dist/bin/uuid"
+                "uuid": "dist-node/bin/uuid"
             }
         },
         "node_modules/v8-compile-cache-lib": {
@@ -14258,19 +14728,20 @@
             }
         },
         "node_modules/vscode-languageclient/node_modules/brace-expansion": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-            "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+            "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
             "dependencies": {
                 "balanced-match": "^1.0.0"
             }
         },
         "node_modules/vscode-languageclient/node_modules/minimatch": {
-            "version": "9.0.3",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz",
-            "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==",
+            "version": "9.0.9",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+            "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+            "license": "ISC",
             "dependencies": {
-                "brace-expansion": "^2.0.1"
+                "brace-expansion": "^2.0.2"
             },
             "engines": {
                 "node": ">=16 || 14 >=14.17"
@@ -14305,9 +14776,9 @@
             }
         },
         "node_modules/watchpack": {
-            "version": "2.4.2",
-            "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
-            "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
+            "version": "2.5.1",
+            "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.5.1.tgz",
+            "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==",
             "dev": true,
             "dependencies": {
                 "glob-to-regexp": "^0.4.1",
@@ -14318,34 +14789,36 @@
             }
         },
         "node_modules/webpack": {
-            "version": "5.94.0",
-            "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
-            "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
-            "dev": true,
-            "dependencies": {
-                "@types/estree": "^1.0.5",
-                "@webassemblyjs/ast": "^1.12.1",
-                "@webassemblyjs/wasm-edit": "^1.12.1",
-                "@webassemblyjs/wasm-parser": "^1.12.1",
-                "acorn": "^8.7.1",
-                "acorn-import-attributes": "^1.9.5",
-                "browserslist": "^4.21.10",
+            "version": "5.105.0",
+            "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.0.tgz",
+            "integrity": "sha512-gX/dMkRQc7QOMzgTe6KsYFM7DxeIONQSui1s0n/0xht36HvrgbxtM1xBlgx596NbpHuQU8P7QpKwrZYwUX48nw==",
+            "dev": true,
+            "dependencies": {
+                "@types/eslint-scope": "^3.7.7",
+                "@types/estree": "^1.0.8",
+                "@types/json-schema": "^7.0.15",
+                "@webassemblyjs/ast": "^1.14.1",
+                "@webassemblyjs/wasm-edit": "^1.14.1",
+                "@webassemblyjs/wasm-parser": "^1.14.1",
+                "acorn": "^8.15.0",
+                "acorn-import-phases": "^1.0.3",
+                "browserslist": "^4.28.1",
                 "chrome-trace-event": "^1.0.2",
-                "enhanced-resolve": "^5.17.1",
-                "es-module-lexer": "^1.2.1",
+                "enhanced-resolve": "^5.19.0",
+                "es-module-lexer": "^2.0.0",
                 "eslint-scope": "5.1.1",
                 "events": "^3.2.0",
                 "glob-to-regexp": "^0.4.1",
                 "graceful-fs": "^4.2.11",
                 "json-parse-even-better-errors": "^2.3.1",
-                "loader-runner": "^4.2.0",
+                "loader-runner": "^4.3.1",
                 "mime-types": "^2.1.27",
                 "neo-async": "^2.6.2",
-                "schema-utils": "^3.2.0",
-                "tapable": "^2.1.1",
-                "terser-webpack-plugin": "^5.3.10",
-                "watchpack": "^2.4.1",
-                "webpack-sources": "^3.2.3"
+                "schema-utils": "^4.3.3",
+                "tapable": "^2.3.0",
+                "terser-webpack-plugin": "^5.3.16",
+                "watchpack": "^2.5.1",
+                "webpack-sources": "^3.3.3"
             },
             "bin": {
                 "webpack": "bin/webpack.js"
@@ -14576,14 +15049,68 @@
             }
         },
         "node_modules/webpack-sources": {
-            "version": "3.2.3",
-            "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
-            "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
+            "version": "3.3.3",
+            "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.3.tgz",
+            "integrity": "sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg==",
             "dev": true,
             "engines": {
                 "node": ">=10.13.0"
             }
         },
+        "node_modules/webpack/node_modules/ajv": {
+            "version": "8.18.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+            "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3",
+                "fast-uri": "^3.0.1",
+                "json-schema-traverse": "^1.0.0",
+                "require-from-string": "^2.0.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/webpack/node_modules/ajv-keywords": {
+            "version": "5.1.0",
+            "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+            "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+            "dev": true,
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3"
+            },
+            "peerDependencies": {
+                "ajv": "^8.8.2"
+            }
+        },
+        "node_modules/webpack/node_modules/json-schema-traverse": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+            "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+            "dev": true
+        },
+        "node_modules/webpack/node_modules/schema-utils": {
+            "version": "4.3.3",
+            "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz",
+            "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
+            "dev": true,
+            "dependencies": {
+                "@types/json-schema": "^7.0.9",
+                "ajv": "^8.9.0",
+                "ajv-formats": "^2.1.1",
+                "ajv-keywords": "^5.1.0"
+            },
+            "engines": {
+                "node": ">= 10.13.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/webpack"
+            }
+        },
         "node_modules/which": {
             "version": "2.0.2",
             "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -14615,15 +15142,18 @@
             }
         },
         "node_modules/which-typed-array": {
-            "version": "1.1.15",
-            "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.15.tgz",
-            "integrity": "sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==",
+            "version": "1.1.19",
+            "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
+            "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
             "dev": true,
+            "license": "MIT",
             "dependencies": {
                 "available-typed-arrays": "^1.0.7",
-                "call-bind": "^1.0.7",
-                "for-each": "^0.3.3",
-                "gopd": "^1.0.1",
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "for-each": "^0.3.5",
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
                 "has-tostringtag": "^1.0.2"
             },
             "engines": {
@@ -14680,9 +15210,9 @@
             }
         },
         "node_modules/workerpool": {
-            "version": "6.5.1",
-            "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
-            "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
+            "version": "9.3.4",
+            "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-9.3.4.tgz",
+            "integrity": "sha512-TmPRQYYSAnnDiEB0P/Ytip7bFGvqnSU6I2BcuSw7Hx+JSg/DsUi5ebYfc8GYaSdpuvOcEs6dXxPurOYpe9QFwg==",
             "dev": true,
             "license": "Apache-2.0"
         },
@@ -15214,6 +15744,11 @@
                     "version": "2.6.2",
                     "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
                     "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="
+                },
+                "uuid": {
+                    "version": "8.3.2",
+                    "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+                    "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
                 }
             }
         },
@@ -15345,6 +15880,12 @@
                     "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-14.12.0.tgz",
                     "integrity": "sha512-IDDXmzfdwmDkv4SSmMEyAniJf6fDu3FJ7ncOjlxkDuT85uSnLEhZi3fGZpoR7T4XZpOMx9teM9GXBgrfJgyeBw==",
                     "dev": true
+                },
+                "uuid": {
+                    "version": "8.3.2",
+                    "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+                    "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+                    "dev": true
                 }
             }
         },
@@ -15368,6 +15909,17 @@
                 }
             }
         },
+        "@babel/code-frame": {
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+            "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+            "dev": true,
+            "requires": {
+                "@babel/helper-validator-identifier": "^7.27.1",
+                "js-tokens": "^4.0.0",
+                "picocolors": "^1.1.1"
+            }
+        },
         "@babel/compat-data": {
             "version": "7.22.6",
             "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.22.6.tgz",
@@ -15397,15 +15949,6 @@
                 "json5": "^2.2.2"
             },
             "dependencies": {
-                "@babel/code-frame": {
-                    "version": "7.22.5",
-                    "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.5.tgz",
-                    "integrity": "sha512-Xmwn266vad+6DAqEB2A6V/CcZVp62BbwVmcOJc2RPuwih1kw02TjQvWVWlcKGbBPd+8/0V5DEkOcizRGYsspYQ==",
-                    "dev": true,
-                    "requires": {
-                        "@babel/highlight": "^7.22.5"
-                    }
-                },
                 "debug": {
                     "version": "4.3.4",
                     "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
@@ -15528,15 +16071,15 @@
             }
         },
         "@babel/helper-string-parser": {
-            "version": "7.22.5",
-            "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz",
-            "integrity": "sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+            "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
             "dev": true
         },
         "@babel/helper-validator-identifier": {
-            "version": "7.22.20",
-            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz",
-            "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+            "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
             "dev": true
         },
         "@babel/helper-validator-option": {
@@ -15546,73 +16089,48 @@
             "dev": true
         },
         "@babel/helpers": {
-            "version": "7.22.6",
-            "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.22.6.tgz",
-            "integrity": "sha512-YjDs6y/fVOYFV8hAf1rxd1QvR9wJe1pDBZ2AREKq/SDayfPzgk0PBnVuTCE5X1acEpMMNOVUqoe+OwiZGJ+OaA==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.1.tgz",
+            "integrity": "sha512-FCvFTm0sWV8Fxhpp2McP5/W53GPllQ9QeQ7SiqGWjMf/LVG07lFa5+pgK05IRhVwtvafT22KF+ZSnM9I545CvQ==",
             "dev": true,
             "requires": {
-                "@babel/template": "^7.22.5",
-                "@babel/traverse": "^7.22.6",
-                "@babel/types": "^7.22.5"
+                "@babel/template": "^7.27.1",
+                "@babel/types": "^7.27.1"
             }
         },
-        "@babel/highlight": {
-            "version": "7.22.20",
-            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz",
-            "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==",
+        "@babel/parser": {
+            "version": "7.27.2",
+            "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.2.tgz",
+            "integrity": "sha512-QYLs8299NA7WM/bZAdp+CviYYkVoYXlDW2rzliy3chxd1PQjej7JORuMJDJXJUb9g0TT+B99EwaVLKmX+sPXWw==",
             "dev": true,
             "requires": {
-                "@babel/helper-validator-identifier": "^7.22.20",
-                "chalk": "^2.4.2",
-                "js-tokens": "^4.0.0"
+                "@babel/types": "^7.27.1"
             }
         },
-        "@babel/parser": {
-            "version": "7.23.0",
-            "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.0.tgz",
-            "integrity": "sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==",
-            "dev": true
-        },
         "@babel/runtime": {
-            "version": "7.17.8",
-            "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.17.8.tgz",
-            "integrity": "sha512-dQpEpK0O9o6lj6oPu0gRDbbnk+4LeHlNcBpspf6Olzt3GIX4P1lWF1gS+pHLDFlaJvbR6q7jCfQ08zA4QJBnmA==",
-            "dev": true,
-            "requires": {
-                "regenerator-runtime": "^0.13.4"
-            }
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz",
+            "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==",
+            "dev": true
         },
         "@babel/runtime-corejs3": {
-            "version": "7.10.5",
-            "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.10.5.tgz",
-            "integrity": "sha512-RMafpmrNB5E/bwdSphLr8a8++9TosnyJp98RZzI6VOx2R2CCMpsXXXRvmI700O9oEKpXdZat6oEK68/F0zjd4A==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.27.1.tgz",
+            "integrity": "sha512-909rVuj3phpjW6y0MCXAZ5iNeORePa6ldJvp2baWGcTjwqbBDDz6xoS5JHJ7lS88NlwLYj07ImL/8IUMtDZzTA==",
             "dev": true,
             "requires": {
-                "core-js-pure": "^3.0.0",
-                "regenerator-runtime": "^0.13.4"
+                "core-js-pure": "^3.30.2"
             }
         },
         "@babel/template": {
-            "version": "7.22.15",
-            "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz",
-            "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==",
+            "version": "7.27.2",
+            "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+            "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
             "dev": true,
             "requires": {
-                "@babel/code-frame": "^7.22.13",
-                "@babel/parser": "^7.22.15",
-                "@babel/types": "^7.22.15"
-            },
-            "dependencies": {
-                "@babel/code-frame": {
-                    "version": "7.22.13",
-                    "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz",
-                    "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==",
-                    "dev": true,
-                    "requires": {
-                        "@babel/highlight": "^7.22.13",
-                        "chalk": "^2.4.2"
-                    }
-                }
+                "@babel/code-frame": "^7.27.1",
+                "@babel/parser": "^7.27.2",
+                "@babel/types": "^7.27.1"
             }
         },
         "@babel/traverse": {
@@ -15633,16 +16151,6 @@
                 "globals": "^11.1.0"
             },
             "dependencies": {
-                "@babel/code-frame": {
-                    "version": "7.22.13",
-                    "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz",
-                    "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==",
-                    "dev": true,
-                    "requires": {
-                        "@babel/highlight": "^7.22.13",
-                        "chalk": "^2.4.2"
-                    }
-                },
                 "debug": {
                     "version": "4.3.4",
                     "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
@@ -15655,14 +16163,13 @@
             }
         },
         "@babel/types": {
-            "version": "7.23.0",
-            "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.0.tgz",
-            "integrity": "sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==",
+            "version": "7.27.1",
+            "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz",
+            "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==",
             "dev": true,
             "requires": {
-                "@babel/helper-string-parser": "^7.22.5",
-                "@babel/helper-validator-identifier": "^7.22.20",
-                "to-fast-properties": "^2.0.0"
+                "@babel/helper-string-parser": "^7.27.1",
+                "@babel/helper-validator-identifier": "^7.27.1"
             }
         },
         "@cspotcode/source-map-consumer": {
@@ -15743,18 +16250,18 @@
                     }
                 },
                 "js-yaml": {
-                    "version": "4.1.0",
-                    "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-                    "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+                    "version": "4.1.1",
+                    "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+                    "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
                     "dev": true,
                     "requires": {
                         "argparse": "^2.0.1"
                     }
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -15816,9 +16323,9 @@
                     }
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -15845,9 +16352,9 @@
             "dev": true
         },
         "@iarna/toml": {
-            "version": "2.2.5",
-            "resolved": "https://registry.npmjs.org/@iarna/toml/-/toml-2.2.5.tgz",
-            "integrity": "sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg=="
+            "version": "3.0.0",
+            "resolved": "https://registry.npmjs.org/@iarna/toml/-/toml-3.0.0.tgz",
+            "integrity": "sha512-td6ZUkz2oS3VeleBcN+m//Q6HlCFCPrnI0FZhrt/h4XqLEdOyYp2u21nd8MdsR+WJy5r9PTDaHTDDfhf4H4l6Q=="
         },
         "@isaacs/cliui": {
             "version": "8.0.2",
@@ -15965,9 +16472,9 @@
             "dev": true
         },
         "@jridgewell/source-map": {
-            "version": "0.3.6",
-            "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz",
-            "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==",
+            "version": "0.3.11",
+            "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+            "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
             "dev": true,
             "requires": {
                 "@jridgewell/gen-mapping": "^0.3.5",
@@ -16413,10 +16920,30 @@
                 "@types/node": "*"
             }
         },
+        "@types/eslint": {
+            "version": "9.6.1",
+            "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz",
+            "integrity": "sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag==",
+            "dev": true,
+            "requires": {
+                "@types/estree": "*",
+                "@types/json-schema": "*"
+            }
+        },
+        "@types/eslint-scope": {
+            "version": "3.7.7",
+            "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz",
+            "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==",
+            "dev": true,
+            "requires": {
+                "@types/eslint": "*",
+                "@types/estree": "*"
+            }
+        },
         "@types/estree": {
-            "version": "1.0.5",
-            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
-            "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+            "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
             "dev": true
         },
         "@types/fs-extra": {
@@ -16451,15 +16978,24 @@
             },
             "dependencies": {
                 "form-data": {
-                    "version": "2.5.1",
-                    "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz",
-                    "integrity": "sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==",
+                    "version": "2.5.5",
+                    "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.5.tgz",
+                    "integrity": "sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A==",
                     "dev": true,
                     "requires": {
                         "asynckit": "^0.4.0",
-                        "combined-stream": "^1.0.6",
-                        "mime-types": "^2.1.12"
+                        "combined-stream": "^1.0.8",
+                        "es-set-tostringtag": "^2.1.0",
+                        "hasown": "^2.0.2",
+                        "mime-types": "^2.1.35",
+                        "safe-buffer": "^5.2.1"
                     }
+                },
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
                 }
             }
         },
@@ -16503,12 +17039,12 @@
             "dev": true
         },
         "@types/node": {
-            "version": "22.5.0",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.5.0.tgz",
-            "integrity": "sha512-DkFrJOe+rfdHTqqMg0bSNlGlQ85hSoh2TPzZyhHsXnMtligRWpxUySiyw8FY14ITt24HVCiQPWxS3KO/QlGmWg==",
+            "version": "22.19.3",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.3.tgz",
+            "integrity": "sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==",
             "dev": true,
             "requires": {
-                "undici-types": "~6.19.2"
+                "undici-types": "~6.21.0"
             }
         },
         "@types/semver": {
@@ -16562,9 +17098,9 @@
             "dev": true
         },
         "@types/vscode": {
-            "version": "1.93.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.93.0.tgz",
-            "integrity": "sha512-kUK6jAHSR5zY8ps42xuW89NLcBpw1kOabah7yv38J8MyiYuOHxLQBi0e7zeXbQgVefDy/mZZetqEFC+Fl5eIEQ==",
+            "version": "1.100.0",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.100.0.tgz",
+            "integrity": "sha512-4uNyvzHoraXEeCamR3+fzcBlh7Afs4Ifjs4epINyUX/jvdk0uzLnwiDY35UKDKnkCHP5Nu3dljl2H8lR6s+rQw==",
             "dev": true
         },
         "@types/which": {
@@ -16698,9 +17234,9 @@
             },
             "dependencies": {
                 "brace-expansion": {
-                    "version": "2.0.1",
-                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-                    "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+                    "version": "2.0.3",
+                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+                    "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
                     "dev": true,
                     "requires": {
                         "balanced-match": "^1.0.0"
@@ -16837,22 +17373,13 @@
                     }
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
                     }
-                },
-                "tmp": {
-                    "version": "0.2.1",
-                    "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz",
-                    "integrity": "sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==",
-                    "dev": true,
-                    "requires": {
-                        "rimraf": "^3.0.0"
-                    }
                 }
             }
         },
@@ -16937,148 +17464,148 @@
             "optional": true
         },
         "@webassemblyjs/ast": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
-            "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+            "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/helper-numbers": "1.11.6",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
+                "@webassemblyjs/helper-numbers": "1.13.2",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
             }
         },
         "@webassemblyjs/floating-point-hex-parser": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz",
-            "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
+            "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==",
             "dev": true
         },
         "@webassemblyjs/helper-api-error": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz",
-            "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
+            "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==",
             "dev": true
         },
         "@webassemblyjs/helper-buffer": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
-            "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
+            "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==",
             "dev": true
         },
         "@webassemblyjs/helper-numbers": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz",
-            "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
+            "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/floating-point-hex-parser": "1.11.6",
-                "@webassemblyjs/helper-api-error": "1.11.6",
+                "@webassemblyjs/floating-point-hex-parser": "1.13.2",
+                "@webassemblyjs/helper-api-error": "1.13.2",
                 "@xtuc/long": "4.2.2"
             }
         },
         "@webassemblyjs/helper-wasm-bytecode": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz",
-            "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
+            "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==",
             "dev": true
         },
         "@webassemblyjs/helper-wasm-section": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
-            "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
+            "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-buffer": "1.12.1",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/wasm-gen": "1.12.1"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-buffer": "1.14.1",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/wasm-gen": "1.14.1"
             }
         },
         "@webassemblyjs/ieee754": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz",
-            "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
+            "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
             "dev": true,
             "requires": {
                 "@xtuc/ieee754": "^1.2.0"
             }
         },
         "@webassemblyjs/leb128": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz",
-            "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
+            "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
             "dev": true,
             "requires": {
                 "@xtuc/long": "4.2.2"
             }
         },
         "@webassemblyjs/utf8": {
-            "version": "1.11.6",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz",
-            "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==",
+            "version": "1.13.2",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
+            "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==",
             "dev": true
         },
         "@webassemblyjs/wasm-edit": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
-            "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
+            "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-buffer": "1.12.1",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/helper-wasm-section": "1.12.1",
-                "@webassemblyjs/wasm-gen": "1.12.1",
-                "@webassemblyjs/wasm-opt": "1.12.1",
-                "@webassemblyjs/wasm-parser": "1.12.1",
-                "@webassemblyjs/wast-printer": "1.12.1"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-buffer": "1.14.1",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/helper-wasm-section": "1.14.1",
+                "@webassemblyjs/wasm-gen": "1.14.1",
+                "@webassemblyjs/wasm-opt": "1.14.1",
+                "@webassemblyjs/wasm-parser": "1.14.1",
+                "@webassemblyjs/wast-printer": "1.14.1"
             }
         },
         "@webassemblyjs/wasm-gen": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
-            "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
+            "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/ieee754": "1.11.6",
-                "@webassemblyjs/leb128": "1.11.6",
-                "@webassemblyjs/utf8": "1.11.6"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/ieee754": "1.13.2",
+                "@webassemblyjs/leb128": "1.13.2",
+                "@webassemblyjs/utf8": "1.13.2"
             }
         },
         "@webassemblyjs/wasm-opt": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
-            "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
+            "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-buffer": "1.12.1",
-                "@webassemblyjs/wasm-gen": "1.12.1",
-                "@webassemblyjs/wasm-parser": "1.12.1"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-buffer": "1.14.1",
+                "@webassemblyjs/wasm-gen": "1.14.1",
+                "@webassemblyjs/wasm-parser": "1.14.1"
             }
         },
         "@webassemblyjs/wasm-parser": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
-            "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
+            "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/ast": "1.12.1",
-                "@webassemblyjs/helper-api-error": "1.11.6",
-                "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-                "@webassemblyjs/ieee754": "1.11.6",
-                "@webassemblyjs/leb128": "1.11.6",
-                "@webassemblyjs/utf8": "1.11.6"
+                "@webassemblyjs/ast": "1.14.1",
+                "@webassemblyjs/helper-api-error": "1.13.2",
+                "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+                "@webassemblyjs/ieee754": "1.13.2",
+                "@webassemblyjs/leb128": "1.13.2",
+                "@webassemblyjs/utf8": "1.13.2"
             }
         },
         "@webassemblyjs/wast-printer": {
-            "version": "1.12.1",
-            "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
-            "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
+            "version": "1.14.1",
+            "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
+            "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
             "dev": true,
             "requires": {
-                "@webassemblyjs/ast": "1.12.1",
+                "@webassemblyjs/ast": "1.14.1",
                 "@xtuc/long": "4.2.2"
             }
         },
@@ -17118,9 +17645,9 @@
             "dev": true
         },
         "acorn": {
-            "version": "8.14.1",
-            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz",
-            "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg=="
+            "version": "8.15.0",
+            "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+            "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="
         },
         "acorn-import-assertions": {
             "version": "1.9.0",
@@ -17128,10 +17655,10 @@
             "integrity": "sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==",
             "requires": {}
         },
-        "acorn-import-attributes": {
-            "version": "1.9.5",
-            "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
-            "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
+        "acorn-import-phases": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz",
+            "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==",
             "dev": true,
             "requires": {}
         },
@@ -17177,9 +17704,9 @@
             }
         },
         "ajv": {
-            "version": "6.12.6",
-            "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-            "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+            "version": "6.14.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+            "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
             "dev": true,
             "requires": {
                 "fast-deep-equal": "^3.1.1",
@@ -17188,6 +17715,35 @@
                 "uri-js": "^4.2.2"
             }
         },
+        "ajv-formats": {
+            "version": "2.1.1",
+            "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
+            "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
+            "dev": true,
+            "requires": {
+                "ajv": "^8.0.0"
+            },
+            "dependencies": {
+                "ajv": {
+                    "version": "8.18.0",
+                    "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+                    "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+                    "dev": true,
+                    "requires": {
+                        "fast-deep-equal": "^3.1.3",
+                        "fast-uri": "^3.0.1",
+                        "json-schema-traverse": "^1.0.0",
+                        "require-from-string": "^2.0.2"
+                    }
+                },
+                "json-schema-traverse": {
+                    "version": "1.0.0",
+                    "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+                    "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+                    "dev": true
+                }
+            }
+        },
         "ajv-keywords": {
             "version": "3.5.2",
             "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
@@ -17433,15 +17989,14 @@
             }
         },
         "asn1.js": {
-            "version": "5.4.1",
-            "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz",
-            "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==",
+            "version": "4.10.1",
+            "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz",
+            "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==",
             "dev": true,
             "requires": {
                 "bn.js": "^4.0.0",
                 "inherits": "^2.0.1",
-                "minimalistic-assert": "^1.0.0",
-                "safer-buffer": "^2.1.0"
+                "minimalistic-assert": "^1.0.0"
             }
         },
         "assert": {
@@ -17645,6 +18200,12 @@
             "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
             "dev": true
         },
+        "baseline-browser-mapping": {
+            "version": "2.9.19",
+            "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.19.tgz",
+            "integrity": "sha512-ipDqC8FrAl/76p2SSWKSI+H9tFwm7vYqXQrItCuiVPt26Km0jS+NzSsBWAaBusvSbQcfJG+JitdMm+wZAgTYqg==",
+            "dev": true
+        },
         "bent": {
             "version": "7.3.12",
             "resolved": "https://registry.npmjs.org/bent/-/bent-7.3.12.tgz",
@@ -17687,9 +18248,9 @@
             }
         },
         "bn.js": {
-            "version": "4.11.8",
-            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz",
-            "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==",
+            "version": "4.12.3",
+            "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.3.tgz",
+            "integrity": "sha512-fGTi3gxV/23FTYdAoUtLYp6qySe2KE3teyZitipKNRuVYcBkoP/bB3guXN/XVKUe9mxCHXnc9C4ocyz8OmgN0g==",
             "dev": true
         },
         "boolbase": {
@@ -17699,9 +18260,9 @@
             "dev": true
         },
         "brace-expansion": {
-            "version": "1.1.11",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-            "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+            "version": "1.1.13",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+            "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
             "requires": {
                 "balanced-match": "^1.0.0",
                 "concat-map": "0.0.1"
@@ -17766,57 +18327,53 @@
             }
         },
         "browserify-rsa": {
-            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz",
-            "integrity": "sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==",
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.1.tgz",
+            "integrity": "sha512-YBjSAiTqM04ZVei6sXighu679a3SqWORA3qZTEqZImnlkDIFtKc6pNutpjyZ8RJTjQtuYfeetkxM11GwoYXMIQ==",
             "dev": true,
             "requires": {
-                "bn.js": "^5.0.0",
-                "randombytes": "^2.0.1"
+                "bn.js": "^5.2.1",
+                "randombytes": "^2.1.0",
+                "safe-buffer": "^5.2.1"
             },
             "dependencies": {
                 "bn.js": {
+                    "version": "5.2.3",
+                    "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.3.tgz",
+                    "integrity": "sha512-EAcmnPkxpntVL+DS7bO1zhcZNvCkxqtkd0ZY53h06GNQ3DEkkGZ/gKgmDv6DdZQGj9BgfSPKtJJ7Dp1GPP8f7w==",
+                    "dev": true
+                },
+                "safe-buffer": {
                     "version": "5.2.1",
-                    "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz",
-                    "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
                     "dev": true
                 }
             }
         },
         "browserify-sign": {
-            "version": "4.2.2",
-            "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.2.tgz",
-            "integrity": "sha512-1rudGyeYY42Dk6texmv7c4VcQ0EsvVbLwZkA+AQB7SxvXxmcD93jcHie8bzecJ+ChDlmAm2Qyu0+Ccg5uhZXCg==",
+            "version": "4.2.5",
+            "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.5.tgz",
+            "integrity": "sha512-C2AUdAJg6rlM2W5QMp2Q4KGQMVBwR1lIimTsUnutJ8bMpW5B52pGpR2gEnNBNwijumDo5FojQ0L9JrXA8m4YEw==",
             "dev": true,
             "requires": {
-                "bn.js": "^5.2.1",
-                "browserify-rsa": "^4.1.0",
+                "bn.js": "^5.2.2",
+                "browserify-rsa": "^4.1.1",
                 "create-hash": "^1.2.0",
                 "create-hmac": "^1.1.7",
-                "elliptic": "^6.5.4",
+                "elliptic": "^6.6.1",
                 "inherits": "^2.0.4",
-                "parse-asn1": "^5.1.6",
-                "readable-stream": "^3.6.2",
+                "parse-asn1": "^5.1.9",
+                "readable-stream": "^2.3.8",
                 "safe-buffer": "^5.2.1"
             },
             "dependencies": {
                 "bn.js": {
-                    "version": "5.2.1",
-                    "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz",
-                    "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==",
+                    "version": "5.2.3",
+                    "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.3.tgz",
+                    "integrity": "sha512-EAcmnPkxpntVL+DS7bO1zhcZNvCkxqtkd0ZY53h06GNQ3DEkkGZ/gKgmDv6DdZQGj9BgfSPKtJJ7Dp1GPP8f7w==",
                     "dev": true
                 },
-                "readable-stream": {
-                    "version": "3.6.2",
-                    "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
-                    "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
-                    "dev": true,
-                    "requires": {
-                        "inherits": "^2.0.3",
-                        "string_decoder": "^1.1.1",
-                        "util-deprecate": "^1.0.1"
-                    }
-                },
                 "safe-buffer": {
                     "version": "5.2.1",
                     "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
@@ -17835,15 +18392,16 @@
             }
         },
         "browserslist": {
-            "version": "4.23.3",
-            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
-            "integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
+            "version": "4.28.1",
+            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+            "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
             "dev": true,
             "requires": {
-                "caniuse-lite": "^1.0.30001646",
-                "electron-to-chromium": "^1.5.4",
-                "node-releases": "^2.0.18",
-                "update-browserslist-db": "^1.1.0"
+                "baseline-browser-mapping": "^2.9.0",
+                "caniuse-lite": "^1.0.30001759",
+                "electron-to-chromium": "^1.5.263",
+                "node-releases": "^2.0.27",
+                "update-browserslist-db": "^1.2.0"
             }
         },
         "buffer": {
@@ -17956,16 +18514,34 @@
             }
         },
         "call-bind": {
-            "version": "1.0.7",
-            "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
-            "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
+            "version": "1.0.8",
+            "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+            "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
             "dev": true,
             "requires": {
+                "call-bind-apply-helpers": "^1.0.0",
                 "es-define-property": "^1.0.0",
-                "es-errors": "^1.3.0",
-                "function-bind": "^1.1.2",
                 "get-intrinsic": "^1.2.4",
-                "set-function-length": "^1.2.1"
+                "set-function-length": "^1.2.2"
+            }
+        },
+        "call-bind-apply-helpers": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+            "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+            "requires": {
+                "es-errors": "^1.3.0",
+                "function-bind": "^1.1.2"
+            }
+        },
+        "call-bound": {
+            "version": "1.0.4",
+            "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+            "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+            "dev": true,
+            "requires": {
+                "call-bind-apply-helpers": "^1.0.2",
+                "get-intrinsic": "^1.3.0"
             }
         },
         "callsites": {
@@ -17981,9 +18557,9 @@
             "dev": true
         },
         "caniuse-lite": {
-            "version": "1.0.30001655",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001655.tgz",
-            "integrity": "sha512-jRGVy3iSGO5Uutn2owlb5gR6qsGngTw9ZTb4ali9f3glshcNmJ2noam4Mo9zia5P9Dk3jNNydy7vQjuE5dQmfg==",
+            "version": "1.0.30001768",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001768.tgz",
+            "integrity": "sha512-qY3aDRZC5nWPgHUgIB84WL+nySuo19wk0VJpp/XI9T34lrvkyhRvNVOFJOp2kxClQhiFBu+TaUSudf6oa3vkSA==",
             "dev": true
         },
         "caseless": {
@@ -18250,13 +18826,22 @@
             }
         },
         "cipher-base": {
-            "version": "1.0.4",
-            "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz",
-            "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
+            "version": "1.0.7",
+            "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.7.tgz",
+            "integrity": "sha512-Mz9QMT5fJe7bKI7MH31UilT5cEK5EHHRCccw/YRFsRY47AuNgaV6HY3rscp0/I4Q+tTW/5zoqpSeRRI54TkDWA==",
             "dev": true,
             "requires": {
-                "inherits": "^2.0.1",
-                "safe-buffer": "^5.0.1"
+                "inherits": "^2.0.4",
+                "safe-buffer": "^5.2.1",
+                "to-buffer": "^1.2.2"
+            },
+            "dependencies": {
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
+                }
             }
         },
         "circular-json": {
@@ -18499,9 +19084,9 @@
             }
         },
         "core-js-pure": {
-            "version": "3.1.4",
-            "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.1.4.tgz",
-            "integrity": "sha512-uJ4Z7iPNwiu1foygbcZYJsJs1jiXrTTCvxfLDXNhI/I+NHbSIEyr548y4fcsCEyWY0XgfAG/qqaunJ1SThHenA==",
+            "version": "3.42.0",
+            "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.42.0.tgz",
+            "integrity": "sha512-007bM04u91fF4kMgwom2I5cQxAFIy8jVulgr9eozILl/SZE53QOqnW/+vviC+wQWLv+AunBG+8Q0TLoeSsSxRQ==",
             "dev": true
         },
         "core-util-is": {
@@ -18511,13 +19096,13 @@
             "dev": true
         },
         "create-ecdh": {
-            "version": "4.0.3",
-            "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz",
-            "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.4.tgz",
+            "integrity": "sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==",
             "dev": true,
             "requires": {
                 "bn.js": "^4.1.0",
-                "elliptic": "^6.0.0"
+                "elliptic": "^6.5.3"
             }
         },
         "create-hash": {
@@ -18633,22 +19218,23 @@
             "dev": true
         },
         "crypto-browserify": {
-            "version": "3.12.0",
-            "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz",
-            "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==",
+            "version": "3.12.1",
+            "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.1.tgz",
+            "integrity": "sha512-r4ESw/IlusD17lgQi1O20Fa3qNnsckR126TdUuBgAu7GBYSIPvdNyONd3Zrxh0xCwA4+6w/TDArBPsMvhur+KQ==",
             "dev": true,
             "requires": {
-                "browserify-cipher": "^1.0.0",
-                "browserify-sign": "^4.0.0",
-                "create-ecdh": "^4.0.0",
-                "create-hash": "^1.1.0",
-                "create-hmac": "^1.1.0",
-                "diffie-hellman": "^5.0.0",
-                "inherits": "^2.0.1",
-                "pbkdf2": "^3.0.3",
-                "public-encrypt": "^4.0.0",
-                "randombytes": "^2.0.0",
-                "randomfill": "^1.0.3"
+                "browserify-cipher": "^1.0.1",
+                "browserify-sign": "^4.2.3",
+                "create-ecdh": "^4.0.4",
+                "create-hash": "^1.2.0",
+                "create-hmac": "^1.1.7",
+                "diffie-hellman": "^5.0.3",
+                "hash-base": "~3.0.4",
+                "inherits": "^2.0.4",
+                "pbkdf2": "^3.1.2",
+                "public-encrypt": "^4.0.3",
+                "randombytes": "^2.1.0",
+                "randomfill": "^1.0.4"
             }
         },
         "damerau-levenshtein": {
@@ -18990,9 +19576,9 @@
             "requires": {}
         },
         "diff": {
-            "version": "4.0.2",
-            "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-            "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.4.tgz",
+            "integrity": "sha512-X07nttJQkwkfKfvTPG/KSnE2OMdcUCao6+eXF3wmnIQRn2aPAHH3VxDbDOdegkd6JbPsXqShpvEOHfAT+nCNwQ==",
             "dev": true
         },
         "diffie-hellman": {
@@ -19067,6 +19653,16 @@
                 }
             }
         },
+        "dunder-proto": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+            "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+            "requires": {
+                "call-bind-apply-helpers": "^1.0.1",
+                "es-errors": "^1.3.0",
+                "gopd": "^1.2.0"
+            }
+        },
         "duplexer": {
             "version": "0.1.2",
             "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz",
@@ -19125,9 +19721,9 @@
             }
         },
         "electron-to-chromium": {
-            "version": "1.5.13",
-            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.13.tgz",
-            "integrity": "sha512-lbBcvtIJ4J6sS4tb5TLp1b4LyfCdMkwStzXPyAgVgTRAsep4bvrAGaBOP7ZJtQMNJpSQ9SqG4brWOroNaQtm7Q==",
+            "version": "1.5.286",
+            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
+            "integrity": "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A==",
             "dev": true
         },
         "elliptic": {
@@ -19143,14 +19739,6 @@
                 "inherits": "^2.0.4",
                 "minimalistic-assert": "^1.0.1",
                 "minimalistic-crypto-utils": "^1.0.1"
-            },
-            "dependencies": {
-                "bn.js": {
-                    "version": "4.12.0",
-                    "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
-                    "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
-                    "dev": true
-                }
             }
         },
         "emitter-listener": {
@@ -19183,13 +19771,13 @@
             }
         },
         "enhanced-resolve": {
-            "version": "5.17.1",
-            "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.17.1.tgz",
-            "integrity": "sha512-LMHl3dXhTcfv8gM4kEzIUeTQ+7fpdA0l2tUf34BddXPkz2A5xJ5L/Pchd5BL6rdccM9QGvu0sWZzK1Z1t4wwyg==",
+            "version": "5.19.0",
+            "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz",
+            "integrity": "sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==",
             "dev": true,
             "requires": {
                 "graceful-fs": "^4.2.4",
-                "tapable": "^2.2.0"
+                "tapable": "^2.3.0"
             }
         },
         "entities": {
@@ -19259,44 +19847,38 @@
             }
         },
         "es-define-property": {
-            "version": "1.0.0",
-            "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
-            "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
-            "dev": true,
-            "requires": {
-                "get-intrinsic": "^1.2.4"
-            }
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+            "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="
         },
         "es-errors": {
             "version": "1.3.0",
             "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-            "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-            "dev": true
+            "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="
         },
         "es-module-lexer": {
-            "version": "1.5.4",
-            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.5.4.tgz",
-            "integrity": "sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw==",
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.0.0.tgz",
+            "integrity": "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==",
             "dev": true
         },
         "es-object-atoms": {
-            "version": "1.0.0",
-            "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
-            "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
-            "dev": true,
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+            "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
             "requires": {
                 "es-errors": "^1.3.0"
             }
         },
         "es-set-tostringtag": {
-            "version": "2.0.3",
-            "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.3.tgz",
-            "integrity": "sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==",
-            "dev": true,
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+            "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
             "requires": {
-                "get-intrinsic": "^1.2.4",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.6",
                 "has-tostringtag": "^1.0.2",
-                "hasown": "^2.0.1"
+                "hasown": "^2.0.2"
             }
         },
         "es-shim-unscopables": {
@@ -19516,9 +20098,9 @@
                     "dev": true
                 },
                 "js-yaml": {
-                    "version": "4.1.0",
-                    "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-                    "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+                    "version": "4.1.1",
+                    "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+                    "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
                     "dev": true,
                     "requires": {
                         "argparse": "^2.0.1"
@@ -19534,9 +20116,9 @@
                     }
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -19684,9 +20266,9 @@
                     }
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -19737,9 +20319,9 @@
                     "dev": true
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -19782,9 +20364,9 @@
                     "dev": true
                 },
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -20084,6 +20666,12 @@
             "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
             "dev": true
         },
+        "fast-uri": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
+            "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
+            "dev": true
+        },
         "fastest-levenshtein": {
             "version": "1.0.12",
             "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.12.tgz",
@@ -20232,9 +20820,9 @@
             }
         },
         "flatted": {
-            "version": "3.2.4",
-            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.4.tgz",
-            "integrity": "sha512-8/sOawo8tJ4QOBX8YlQBMxL8+RLZfxMQOif9o0KUKTNTjMYElWPE0r/m5VNFxTRd0NSw8qSy8dajrwX4RYI1Hw==",
+            "version": "3.4.2",
+            "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+            "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
             "dev": true
         },
         "flush-write-stream": {
@@ -20248,12 +20836,12 @@
             }
         },
         "for-each": {
-            "version": "0.3.3",
-            "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
-            "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
+            "version": "0.3.5",
+            "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+            "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
             "dev": true,
             "requires": {
-                "is-callable": "^1.1.3"
+                "is-callable": "^1.2.7"
             }
         },
         "for-in": {
@@ -20316,12 +20904,14 @@
             }
         },
         "form-data": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
-            "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+            "version": "4.0.4",
+            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+            "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
             "requires": {
                 "asynckit": "^0.4.0",
                 "combined-stream": "^1.0.8",
+                "es-set-tostringtag": "^2.1.0",
+                "hasown": "^2.0.2",
                 "mime-types": "^2.1.12"
             }
         },
@@ -20446,16 +21036,20 @@
             "dev": true
         },
         "get-intrinsic": {
-            "version": "1.2.4",
-            "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
-            "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
-            "dev": true,
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+            "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
             "requires": {
+                "call-bind-apply-helpers": "^1.0.2",
+                "es-define-property": "^1.0.1",
                 "es-errors": "^1.3.0",
+                "es-object-atoms": "^1.1.1",
                 "function-bind": "^1.1.2",
-                "has-proto": "^1.0.1",
-                "has-symbols": "^1.0.3",
-                "hasown": "^2.0.0"
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
+                "has-symbols": "^1.1.0",
+                "hasown": "^2.0.2",
+                "math-intrinsics": "^1.1.0"
             }
         },
         "get-package-type": {
@@ -20470,6 +21064,15 @@
             "integrity": "sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==",
             "dev": true
         },
+        "get-proto": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+            "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+            "requires": {
+                "dunder-proto": "^1.0.1",
+                "es-object-atoms": "^1.0.0"
+            }
+        },
         "get-stream": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz",
@@ -20523,9 +21126,9 @@
             },
             "dependencies": {
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "requires": {
                         "brace-expansion": "^1.1.7"
                     }
@@ -20662,13 +21265,9 @@
             }
         },
         "gopd": {
-            "version": "1.0.1",
-            "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
-            "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
-            "dev": true,
-            "requires": {
-                "get-intrinsic": "^1.1.3"
-            }
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+            "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="
         },
         "got": {
             "version": "8.3.2",
@@ -21060,10 +21659,9 @@
             "dev": true
         },
         "has-symbols": {
-            "version": "1.0.3",
-            "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
-            "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
-            "dev": true
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+            "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="
         },
         "has-to-string-tag-x": {
             "version": "1.4.1",
@@ -21078,7 +21676,6 @@
             "version": "1.0.2",
             "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
             "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-            "dev": true,
             "requires": {
                 "has-symbols": "^1.0.3"
             }
@@ -21616,12 +22213,12 @@
             }
         },
         "is-typed-array": {
-            "version": "1.1.13",
-            "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz",
-            "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==",
+            "version": "1.1.15",
+            "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+            "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
             "dev": true,
             "requires": {
-                "which-typed-array": "^1.1.14"
+                "which-typed-array": "^1.1.16"
             }
         },
         "is-typedarray": {
@@ -21787,6 +22384,12 @@
                     "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
                     "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
                     "dev": true
+                },
+                "uuid": {
+                    "version": "8.3.2",
+                    "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+                    "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+                    "dev": true
                 }
             }
         },
@@ -21905,9 +22508,9 @@
             "dev": true
         },
         "js-yaml": {
-            "version": "3.13.1",
-            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz",
-            "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==",
+            "version": "3.14.2",
+            "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
+            "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
             "dev": true,
             "requires": {
                 "argparse": "^1.0.7",
@@ -21982,23 +22585,23 @@
             },
             "dependencies": {
                 "jwa": {
-                    "version": "1.4.1",
-                    "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.1.tgz",
-                    "integrity": "sha512-qiLX/xhEEFKUAJ6FiBMbes3w9ATzyk5W7Hvzpa/SLYdxNtng+gcurvrI7TbACjIXlsJyr05/S1oUhZrc63evQA==",
+                    "version": "1.4.2",
+                    "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.2.tgz",
+                    "integrity": "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==",
                     "dev": true,
                     "requires": {
-                        "buffer-equal-constant-time": "1.0.1",
+                        "buffer-equal-constant-time": "^1.0.1",
                         "ecdsa-sig-formatter": "1.0.11",
                         "safe-buffer": "^5.0.1"
                     }
                 },
                 "jws": {
-                    "version": "3.2.2",
-                    "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz",
-                    "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==",
+                    "version": "3.2.3",
+                    "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.3.tgz",
+                    "integrity": "sha512-byiJ0FLRdLdSVSReO/U4E7RoEyOCKnEnEPMjq3HxWtvzLsV08/i5RQKsFVNkCldrCaPr2vDNAOMsfs8T/Hze7g==",
                     "dev": true,
                     "requires": {
-                        "jwa": "^1.4.1",
+                        "jwa": "^1.4.2",
                         "safe-buffer": "^5.0.1"
                     }
                 }
@@ -22033,23 +22636,23 @@
             "dev": true
         },
         "jwa": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
-            "integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+            "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
             "dev": true,
             "requires": {
-                "buffer-equal-constant-time": "1.0.1",
+                "buffer-equal-constant-time": "^1.0.1",
                 "ecdsa-sig-formatter": "1.0.11",
                 "safe-buffer": "^5.0.1"
             }
         },
         "jws": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
-            "integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
+            "version": "4.0.1",
+            "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
+            "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
             "dev": true,
             "requires": {
-                "jwa": "^2.0.0",
+                "jwa": "^2.0.1",
                 "safe-buffer": "^5.0.1"
             }
         },
@@ -22176,9 +22779,9 @@
             }
         },
         "loader-runner": {
-            "version": "4.2.0",
-            "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.2.0.tgz",
-            "integrity": "sha512-92+huvxMvYlMzMt0iIOukcwYBFpkYJdpl2xsZ7LrlayO7E8SOv+JJUEK17B/dJIHAOLMfh2dZZ/Y18WgmGtYNw==",
+            "version": "4.3.1",
+            "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.1.tgz",
+            "integrity": "sha512-IWqP2SCPhyVFTBtRcgMHdzlf9ul25NwaFx4wCEH/KjAXuuHY4yNjvPXsBokp8jCB936PyWRaPKUNh8NvylLp2Q==",
             "dev": true
         },
         "loader-utils": {
@@ -22202,15 +22805,9 @@
             }
         },
         "lodash": {
-            "version": "4.17.21",
-            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
-            "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
-        },
-        "lodash._reinterpolate": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz",
-            "integrity": "sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=",
-            "dev": true
+            "version": "4.18.1",
+            "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+            "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q=="
         },
         "lodash.flattendeep": {
             "version": "4.4.0",
@@ -22272,31 +22869,6 @@
             "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
             "dev": true
         },
-        "lodash.some": {
-            "version": "4.6.0",
-            "resolved": "https://registry.npmjs.org/lodash.some/-/lodash.some-4.6.0.tgz",
-            "integrity": "sha1-G7nzFO9ri63tE7VJFpsqlF62jk0=",
-            "dev": true
-        },
-        "lodash.template": {
-            "version": "4.5.0",
-            "resolved": "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz",
-            "integrity": "sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==",
-            "dev": true,
-            "requires": {
-                "lodash._reinterpolate": "^3.0.0",
-                "lodash.templatesettings": "^4.0.0"
-            }
-        },
-        "lodash.templatesettings": {
-            "version": "4.2.0",
-            "resolved": "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz",
-            "integrity": "sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==",
-            "dev": true,
-            "requires": {
-                "lodash._reinterpolate": "^3.0.0"
-            }
-        },
         "log-symbols": {
             "version": "4.1.0",
             "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
@@ -22440,6 +23012,11 @@
                 }
             }
         },
+        "math-intrinsics": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+            "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="
+        },
         "md5": {
             "version": "2.3.0",
             "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz",
@@ -22543,17 +23120,17 @@
             "dev": true
         },
         "minimatch": {
-            "version": "5.1.0",
-            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.0.tgz",
-            "integrity": "sha512-9TPBGGak4nHfGZsPBohm9AWg6NoT7QTCehS3BIJABslyZbzxfV78QM2Y6+i741OPZIafFAaiiEMh5OyIrJPgtg==",
+            "version": "5.1.8",
+            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.8.tgz",
+            "integrity": "sha512-7RN35vit8DeBclkofOVmBY0eDAZZQd1HzmukRdSyz95CRh8FT54eqnbj0krQr3mrHR6sfRyYkyhwBWjoV5uqlQ==",
             "requires": {
                 "brace-expansion": "^2.0.1"
             },
             "dependencies": {
                 "brace-expansion": {
-                    "version": "2.0.1",
-                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-                    "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+                    "version": "2.0.3",
+                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+                    "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
                     "requires": {
                         "balanced-match": "^1.0.0"
                     }
@@ -22589,39 +23166,34 @@
             "optional": true
         },
         "mocha": {
-            "version": "11.1.0",
-            "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.1.0.tgz",
-            "integrity": "sha512-8uJR5RTC2NgpY3GrYcgpZrsEd9zKbPDpob1RezyR2upGHRQtHWofmzTMzTMSV6dru3tj5Ukt0+Vnq1qhFEEwAg==",
+            "version": "11.7.5",
+            "resolved": "https://registry.npmjs.org/mocha/-/mocha-11.7.5.tgz",
+            "integrity": "sha512-mTT6RgopEYABzXWFx+GcJ+ZQ32kp4fMf0xvpZIIfSq9Z8lC/++MtcCnQ9t5FP2veYEP95FIYSvW+U9fV4xrlig==",
             "dev": true,
             "requires": {
-                "ansi-colors": "^4.1.3",
                 "browser-stdout": "^1.3.1",
-                "chokidar": "^3.5.3",
+                "chokidar": "^4.0.1",
                 "debug": "^4.3.5",
-                "diff": "^5.2.0",
+                "diff": "^7.0.0",
                 "escape-string-regexp": "^4.0.0",
                 "find-up": "^5.0.0",
                 "glob": "^10.4.5",
                 "he": "^1.2.0",
+                "is-path-inside": "^3.0.3",
                 "js-yaml": "^4.1.0",
                 "log-symbols": "^4.1.0",
-                "minimatch": "^5.1.6",
+                "minimatch": "^9.0.5",
                 "ms": "^2.1.3",
+                "picocolors": "^1.1.1",
                 "serialize-javascript": "^6.0.2",
                 "strip-json-comments": "^3.1.1",
                 "supports-color": "^8.1.1",
-                "workerpool": "^6.5.1",
+                "workerpool": "^9.2.0",
                 "yargs": "^17.7.2",
                 "yargs-parser": "^21.1.1",
                 "yargs-unparser": "^2.0.0"
             },
             "dependencies": {
-                "ansi-colors": {
-                    "version": "4.1.3",
-                    "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
-                    "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
-                    "dev": true
-                },
                 "argparse": {
                     "version": "2.0.1",
                     "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
@@ -22629,14 +23201,23 @@
                     "dev": true
                 },
                 "brace-expansion": {
-                    "version": "2.0.1",
-                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-                    "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+                    "version": "2.0.3",
+                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+                    "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
                     "dev": true,
                     "requires": {
                         "balanced-match": "^1.0.0"
                     }
                 },
+                "chokidar": {
+                    "version": "4.0.3",
+                    "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+                    "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+                    "dev": true,
+                    "requires": {
+                        "readdirp": "^4.0.1"
+                    }
+                },
                 "cliui": {
                     "version": "8.0.1",
                     "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
@@ -22669,9 +23250,9 @@
                     }
                 },
                 "diff": {
-                    "version": "5.2.0",
-                    "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
-                    "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
+                    "version": "7.0.0",
+                    "resolved": "https://registry.npmjs.org/diff/-/diff-7.0.0.tgz",
+                    "integrity": "sha512-PJWHUb1RFevKCwaFA9RlG5tCd+FO5iRh9A8HEtkmBH2Li03iJriB6m6JIN4rGz3K3JLawI7/veA1xzRKP6ISBw==",
                     "dev": true
                 },
                 "escape-string-regexp": {
@@ -22701,9 +23282,9 @@
                     }
                 },
                 "glob": {
-                    "version": "10.4.5",
-                    "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
-                    "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
+                    "version": "10.5.0",
+                    "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+                    "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
                     "dev": true,
                     "requires": {
                         "foreground-child": "^3.1.0",
@@ -22712,17 +23293,6 @@
                         "minipass": "^7.1.2",
                         "package-json-from-dist": "^1.0.0",
                         "path-scurry": "^1.11.1"
-                    },
-                    "dependencies": {
-                        "minimatch": {
-                            "version": "9.0.5",
-                            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-                            "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
-                            "dev": true,
-                            "requires": {
-                                "brace-expansion": "^2.0.1"
-                            }
-                        }
                     }
                 },
                 "has-flag": {
@@ -22732,9 +23302,9 @@
                     "dev": true
                 },
                 "js-yaml": {
-                    "version": "4.1.0",
-                    "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-                    "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+                    "version": "4.1.1",
+                    "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+                    "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
                     "dev": true,
                     "requires": {
                         "argparse": "^2.0.1"
@@ -22750,12 +23320,12 @@
                     }
                 },
                 "minimatch": {
-                    "version": "5.1.6",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-                    "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+                    "version": "9.0.9",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+                    "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
                     "dev": true,
                     "requires": {
-                        "brace-expansion": "^2.0.1"
+                        "brace-expansion": "^2.0.2"
                     }
                 },
                 "ms": {
@@ -22788,6 +23358,12 @@
                     "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
                     "dev": true
                 },
+                "readdirp": {
+                    "version": "4.1.2",
+                    "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+                    "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+                    "dev": true
+                },
                 "shebang-command": {
                     "version": "2.0.0",
                     "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -23175,9 +23751,9 @@
             }
         },
         "node-releases": {
-            "version": "2.0.18",
-            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
-            "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
+            "version": "2.0.27",
+            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+            "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
             "dev": true
         },
         "node-stream-zip": {
@@ -23290,9 +23866,9 @@
             "dev": true
         },
         "object-inspect": {
-            "version": "1.13.1",
-            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz",
-            "integrity": "sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==",
+            "version": "1.13.4",
+            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+            "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
             "dev": true
         },
         "object-is": {
@@ -23462,11 +24038,6 @@
             "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=",
             "dev": true
         },
-        "os-tmpdir": {
-            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-            "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ="
-        },
         "p-cancelable": {
             "version": "0.4.1",
             "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.4.1.tgz",
@@ -23570,16 +24141,24 @@
             }
         },
         "parse-asn1": {
-            "version": "5.1.6",
-            "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.6.tgz",
-            "integrity": "sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==",
+            "version": "5.1.9",
+            "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.9.tgz",
+            "integrity": "sha512-fIYNuZ/HastSb80baGOuPRo1O9cf4baWw5WsAp7dBuUzeTD/BoaG8sVTdlPFksBE2lF21dN+A1AnrpIjSWqHHg==",
             "dev": true,
             "requires": {
-                "asn1.js": "^5.2.0",
-                "browserify-aes": "^1.0.0",
-                "evp_bytestokey": "^1.0.0",
-                "pbkdf2": "^3.0.3",
-                "safe-buffer": "^5.1.1"
+                "asn1.js": "^4.10.1",
+                "browserify-aes": "^1.2.0",
+                "evp_bytestokey": "^1.0.3",
+                "pbkdf2": "^3.1.5",
+                "safe-buffer": "^5.2.1"
+            },
+            "dependencies": {
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
+                }
             }
         },
         "parse-filepath": {
@@ -23719,16 +24298,25 @@
             "dev": true
         },
         "pbkdf2": {
-            "version": "3.0.17",
-            "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz",
-            "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==",
+            "version": "3.1.5",
+            "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.5.tgz",
+            "integrity": "sha512-Q3CG/cYvCO1ye4QKkuH7EXxs3VC/rI1/trd+qX2+PolbaKG0H+bgcZzrTt96mMyRtejk+JMCiLUn3y29W8qmFQ==",
             "dev": true,
             "requires": {
-                "create-hash": "^1.1.2",
-                "create-hmac": "^1.1.4",
-                "ripemd160": "^2.0.1",
-                "safe-buffer": "^5.0.1",
-                "sha.js": "^2.4.8"
+                "create-hash": "^1.2.0",
+                "create-hmac": "^1.1.7",
+                "ripemd160": "^2.0.3",
+                "safe-buffer": "^5.2.1",
+                "sha.js": "^2.4.12",
+                "to-buffer": "^1.2.1"
+            },
+            "dependencies": {
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
+                }
             }
         },
         "pend": {
@@ -23738,15 +24326,15 @@
             "dev": true
         },
         "picocolors": {
-            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-            "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+            "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
             "dev": true
         },
         "picomatch": {
-            "version": "2.3.1",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-            "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+            "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
             "dev": true
         },
         "pify": {
@@ -23929,12 +24517,12 @@
             "dev": true
         },
         "qs": {
-            "version": "6.12.1",
-            "resolved": "https://registry.npmjs.org/qs/-/qs-6.12.1.tgz",
-            "integrity": "sha512-zWmv4RSuB9r2mYQw3zxQuHWeU+42aKi1wWig/j4ele4ygELZ7PEO6MM7rim9oAQH2A5MWfsAVf/jPvTPgCbvUQ==",
+            "version": "6.15.0",
+            "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.0.tgz",
+            "integrity": "sha512-mAZTtNCeetKMH+pSjrb76NAM8V9a05I9aBZOHztWy/UqcJdQYNsf59vrRKWnojAT9Y+GbIvoTBC++CPHqpDBhQ==",
             "dev": true,
             "requires": {
-                "side-channel": "^1.0.6"
+                "side-channel": "^1.1.0"
             }
         },
         "query-string": {
@@ -24029,9 +24617,9 @@
             }
         },
         "readable-stream": {
-            "version": "2.3.7",
-            "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
-            "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
+            "version": "2.3.8",
+            "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+            "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
             "dev": true,
             "requires": {
                 "core-util-is": "~1.0.0",
@@ -24077,12 +24665,6 @@
             "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
             "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q=="
         },
-        "regenerator-runtime": {
-            "version": "0.13.9",
-            "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz",
-            "integrity": "sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==",
-            "dev": true
-        },
         "regexp.prototype.flags": {
             "version": "1.5.2",
             "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz",
@@ -24149,6 +24731,12 @@
             "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=",
             "dev": true
         },
+        "require-from-string": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+            "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+            "dev": true
+        },
         "require-in-the-middle": {
             "version": "7.2.0",
             "resolved": "https://registry.npmjs.org/require-in-the-middle/-/require-in-the-middle-7.2.0.tgz",
@@ -24229,15 +24817,13 @@
             "dev": true
         },
         "rewiremock": {
-            "version": "3.14.5",
-            "resolved": "https://registry.npmjs.org/rewiremock/-/rewiremock-3.14.5.tgz",
-            "integrity": "sha512-MdPutvaUd+kKVz/lcEz6N6337s4PxRUR5vhphIp2/TJRgfXIckomIkCsIAbwB53MjiSLwi7KBMdQ9lPWE5WpYA==",
+            "version": "3.14.6",
+            "resolved": "https://registry.npmjs.org/rewiremock/-/rewiremock-3.14.6.tgz",
+            "integrity": "sha512-hjpS7iQUTVVh/IHV4GE1ypg4IzlgVc34gxZBarwwVrKfnjlyqHJuQdsia6Ac7m4f4k/zxxA3tX285MOstdysRQ==",
             "dev": true,
             "requires": {
                 "babel-runtime": "^6.26.0",
                 "compare-module-exports": "^2.1.0",
-                "lodash.some": "^4.6.0",
-                "lodash.template": "^4.4.0",
                 "node-libs-browser": "^2.1.0",
                 "path-parse": "^1.0.5",
                 "wipe-node-cache": "^2.1.2",
@@ -24254,13 +24840,33 @@
             }
         },
         "ripemd160": {
-            "version": "2.0.2",
-            "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz",
-            "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==",
+            "version": "2.0.3",
+            "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.3.tgz",
+            "integrity": "sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==",
             "dev": true,
             "requires": {
-                "hash-base": "^3.0.0",
-                "inherits": "^2.0.1"
+                "hash-base": "^3.1.2",
+                "inherits": "^2.0.4"
+            },
+            "dependencies": {
+                "hash-base": {
+                    "version": "3.1.2",
+                    "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.2.tgz",
+                    "integrity": "sha512-Bb33KbowVTIj5s7Ked1OsqHUeCpz//tPwR+E2zJgJKo9Z5XolZ9b6bdUgjmYlwnWhoOQKoTd1TYToZGn5mAYOg==",
+                    "dev": true,
+                    "requires": {
+                        "inherits": "^2.0.4",
+                        "readable-stream": "^2.3.8",
+                        "safe-buffer": "^5.2.1",
+                        "to-buffer": "^1.2.1"
+                    }
+                },
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
+                }
             }
         },
         "run-parallel": {
@@ -24417,13 +25023,22 @@
             "dev": true
         },
         "sha.js": {
-            "version": "2.4.11",
-            "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz",
-            "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
+            "version": "2.4.12",
+            "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.12.tgz",
+            "integrity": "sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==",
             "dev": true,
             "requires": {
-                "inherits": "^2.0.1",
-                "safe-buffer": "^5.0.1"
+                "inherits": "^2.0.4",
+                "safe-buffer": "^5.2.1",
+                "to-buffer": "^1.2.0"
+            },
+            "dependencies": {
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
+                }
             }
         },
         "shallow-clone": {
@@ -24465,15 +25080,51 @@
             }
         },
         "side-channel": {
-            "version": "1.0.6",
-            "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
-            "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+            "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
             "dev": true,
             "requires": {
-                "call-bind": "^1.0.7",
                 "es-errors": "^1.3.0",
-                "get-intrinsic": "^1.2.4",
-                "object-inspect": "^1.13.1"
+                "object-inspect": "^1.13.3",
+                "side-channel-list": "^1.0.0",
+                "side-channel-map": "^1.0.1",
+                "side-channel-weakmap": "^1.0.2"
+            }
+        },
+        "side-channel-list": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+            "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+            "dev": true,
+            "requires": {
+                "es-errors": "^1.3.0",
+                "object-inspect": "^1.13.3"
+            }
+        },
+        "side-channel-map": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+            "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+            "dev": true,
+            "requires": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.5",
+                "object-inspect": "^1.13.3"
+            }
+        },
+        "side-channel-weakmap": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+            "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+            "dev": true,
+            "requires": {
+                "call-bound": "^1.0.2",
+                "es-errors": "^1.3.0",
+                "get-intrinsic": "^1.2.5",
+                "object-inspect": "^1.13.3",
+                "side-channel-map": "^1.0.1"
             }
         },
         "signal-exit": {
@@ -24535,9 +25186,9 @@
             },
             "dependencies": {
                 "diff": {
-                    "version": "5.2.0",
-                    "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz",
-                    "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==",
+                    "version": "5.2.2",
+                    "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.2.tgz",
+                    "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
                     "dev": true
                 },
                 "has-flag": {
@@ -24898,15 +25549,15 @@
             }
         },
         "tapable": {
-            "version": "2.2.1",
-            "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz",
-            "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==",
+            "version": "2.3.0",
+            "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz",
+            "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==",
             "dev": true
         },
         "tar-fs": {
-            "version": "2.1.1",
-            "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.1.tgz",
-            "integrity": "sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==",
+            "version": "2.1.4",
+            "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+            "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
             "dev": true,
             "optional": true,
             "requires": {
@@ -24997,28 +25648,68 @@
             }
         },
         "terser": {
-            "version": "5.31.6",
-            "resolved": "https://registry.npmjs.org/terser/-/terser-5.31.6.tgz",
-            "integrity": "sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==",
+            "version": "5.46.0",
+            "resolved": "https://registry.npmjs.org/terser/-/terser-5.46.0.tgz",
+            "integrity": "sha512-jTwoImyr/QbOWFFso3YoU3ik0jBBDJ6JTOQiy/J2YxVJdZCc+5u7skhNwiOR3FQIygFqVUPHl7qbbxtjW2K3Qg==",
             "dev": true,
             "requires": {
                 "@jridgewell/source-map": "^0.3.3",
-                "acorn": "^8.8.2",
+                "acorn": "^8.15.0",
                 "commander": "^2.20.0",
                 "source-map-support": "~0.5.20"
             }
         },
         "terser-webpack-plugin": {
-            "version": "5.3.10",
-            "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
-            "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
+            "version": "5.3.17",
+            "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.17.tgz",
+            "integrity": "sha512-YR7PtUp6GMU91BgSJmlaX/rS2lGDbAF7D+Wtq7hRO+MiljNmodYvqslzCFiYVAgW+Qoaaia/QUIP4lGXufjdZw==",
             "dev": true,
             "requires": {
-                "@jridgewell/trace-mapping": "^0.3.20",
+                "@jridgewell/trace-mapping": "^0.3.25",
                 "jest-worker": "^27.4.5",
-                "schema-utils": "^3.1.1",
-                "serialize-javascript": "^6.0.1",
-                "terser": "^5.26.0"
+                "schema-utils": "^4.3.0",
+                "terser": "^5.31.1"
+            },
+            "dependencies": {
+                "ajv": {
+                    "version": "8.18.0",
+                    "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+                    "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+                    "dev": true,
+                    "requires": {
+                        "fast-deep-equal": "^3.1.3",
+                        "fast-uri": "^3.0.1",
+                        "json-schema-traverse": "^1.0.0",
+                        "require-from-string": "^2.0.2"
+                    }
+                },
+                "ajv-keywords": {
+                    "version": "5.1.0",
+                    "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+                    "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+                    "dev": true,
+                    "requires": {
+                        "fast-deep-equal": "^3.1.3"
+                    }
+                },
+                "json-schema-traverse": {
+                    "version": "1.0.0",
+                    "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+                    "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+                    "dev": true
+                },
+                "schema-utils": {
+                    "version": "4.3.3",
+                    "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz",
+                    "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
+                    "dev": true,
+                    "requires": {
+                        "@types/json-schema": "^7.0.9",
+                        "ajv": "^8.9.0",
+                        "ajv-formats": "^2.1.1",
+                        "ajv-keywords": "^5.1.0"
+                    }
+                }
             }
         },
         "test-exclude": {
@@ -25033,9 +25724,9 @@
             },
             "dependencies": {
                 "minimatch": {
-                    "version": "3.1.2",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-                    "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+                    "version": "3.1.5",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+                    "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
                     "dev": true,
                     "requires": {
                         "brace-expansion": "^1.1.7"
@@ -25100,12 +25791,9 @@
             }
         },
         "tmp": {
-            "version": "0.0.33",
-            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-            "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-            "requires": {
-                "os-tmpdir": "~1.0.2"
-            }
+            "version": "0.2.5",
+            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
+            "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow=="
         },
         "to-absolute-glob": {
             "version": "2.0.2",
@@ -25124,16 +25812,29 @@
             "dev": true
         },
         "to-buffer": {
-            "version": "1.1.1",
-            "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.1.1.tgz",
-            "integrity": "sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==",
-            "dev": true
-        },
-        "to-fast-properties": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
-            "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==",
-            "dev": true
+            "version": "1.2.2",
+            "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.2.2.tgz",
+            "integrity": "sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==",
+            "dev": true,
+            "requires": {
+                "isarray": "^2.0.5",
+                "safe-buffer": "^5.2.1",
+                "typed-array-buffer": "^1.0.3"
+            },
+            "dependencies": {
+                "isarray": {
+                    "version": "2.0.5",
+                    "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+                    "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+                    "dev": true
+                },
+                "safe-buffer": {
+                    "version": "5.2.1",
+                    "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+                    "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+                    "dev": true
+                }
+            }
         },
         "to-regex-range": {
             "version": "5.0.1",
@@ -25408,14 +26109,14 @@
             "dev": true
         },
         "typed-array-buffer": {
-            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz",
-            "integrity": "sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==",
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+            "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
             "dev": true,
             "requires": {
-                "call-bind": "^1.0.7",
+                "call-bound": "^1.0.3",
                 "es-errors": "^1.3.0",
-                "is-typed-array": "^1.1.13"
+                "is-typed-array": "^1.1.14"
             }
         },
         "typed-array-byte-length": {
@@ -25571,9 +26272,9 @@
             "dev": true
         },
         "undici-types": {
-            "version": "6.19.8",
-            "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
-            "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
+            "version": "6.21.0",
+            "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+            "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
             "dev": true
         },
         "unicode": {
@@ -25592,13 +26293,13 @@
             }
         },
         "update-browserslist-db": {
-            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
-            "integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+            "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
             "dev": true,
             "requires": {
-                "escalade": "^3.1.2",
-                "picocolors": "^1.0.1"
+                "escalade": "^3.2.0",
+                "picocolors": "^1.1.1"
             }
         },
         "uri-js": {
@@ -25673,9 +26374,10 @@
             "dev": true
         },
         "uuid": {
-            "version": "8.3.2",
-            "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
-            "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="
+            "version": "14.0.0",
+            "resolved": "https://registry.npmjs.org/uuid/-/uuid-14.0.0.tgz",
+            "integrity": "sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==",
+            "dev": true
         },
         "v8-compile-cache-lib": {
             "version": "3.0.0",
@@ -25850,19 +26552,19 @@
             },
             "dependencies": {
                 "brace-expansion": {
-                    "version": "2.0.1",
-                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-                    "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+                    "version": "2.0.3",
+                    "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+                    "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
                     "requires": {
                         "balanced-match": "^1.0.0"
                     }
                 },
                 "minimatch": {
-                    "version": "9.0.3",
-                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz",
-                    "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==",
+                    "version": "9.0.9",
+                    "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+                    "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
                     "requires": {
-                        "brace-expansion": "^2.0.1"
+                        "brace-expansion": "^2.0.2"
                     }
                 }
             }
@@ -25890,9 +26592,9 @@
             }
         },
         "watchpack": {
-            "version": "2.4.2",
-            "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
-            "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
+            "version": "2.5.1",
+            "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.5.1.tgz",
+            "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==",
             "dev": true,
             "requires": {
                 "glob-to-regexp": "^0.4.1",
@@ -25900,34 +26602,77 @@
             }
         },
         "webpack": {
-            "version": "5.94.0",
-            "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
-            "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
-            "dev": true,
-            "requires": {
-                "@types/estree": "^1.0.5",
-                "@webassemblyjs/ast": "^1.12.1",
-                "@webassemblyjs/wasm-edit": "^1.12.1",
-                "@webassemblyjs/wasm-parser": "^1.12.1",
-                "acorn": "^8.7.1",
-                "acorn-import-attributes": "^1.9.5",
-                "browserslist": "^4.21.10",
+            "version": "5.105.0",
+            "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.0.tgz",
+            "integrity": "sha512-gX/dMkRQc7QOMzgTe6KsYFM7DxeIONQSui1s0n/0xht36HvrgbxtM1xBlgx596NbpHuQU8P7QpKwrZYwUX48nw==",
+            "dev": true,
+            "requires": {
+                "@types/eslint-scope": "^3.7.7",
+                "@types/estree": "^1.0.8",
+                "@types/json-schema": "^7.0.15",
+                "@webassemblyjs/ast": "^1.14.1",
+                "@webassemblyjs/wasm-edit": "^1.14.1",
+                "@webassemblyjs/wasm-parser": "^1.14.1",
+                "acorn": "^8.15.0",
+                "acorn-import-phases": "^1.0.3",
+                "browserslist": "^4.28.1",
                 "chrome-trace-event": "^1.0.2",
-                "enhanced-resolve": "^5.17.1",
-                "es-module-lexer": "^1.2.1",
+                "enhanced-resolve": "^5.19.0",
+                "es-module-lexer": "^2.0.0",
                 "eslint-scope": "5.1.1",
                 "events": "^3.2.0",
                 "glob-to-regexp": "^0.4.1",
                 "graceful-fs": "^4.2.11",
                 "json-parse-even-better-errors": "^2.3.1",
-                "loader-runner": "^4.2.0",
+                "loader-runner": "^4.3.1",
                 "mime-types": "^2.1.27",
                 "neo-async": "^2.6.2",
-                "schema-utils": "^3.2.0",
-                "tapable": "^2.1.1",
-                "terser-webpack-plugin": "^5.3.10",
-                "watchpack": "^2.4.1",
-                "webpack-sources": "^3.2.3"
+                "schema-utils": "^4.3.3",
+                "tapable": "^2.3.0",
+                "terser-webpack-plugin": "^5.3.16",
+                "watchpack": "^2.5.1",
+                "webpack-sources": "^3.3.3"
+            },
+            "dependencies": {
+                "ajv": {
+                    "version": "8.18.0",
+                    "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+                    "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+                    "dev": true,
+                    "requires": {
+                        "fast-deep-equal": "^3.1.3",
+                        "fast-uri": "^3.0.1",
+                        "json-schema-traverse": "^1.0.0",
+                        "require-from-string": "^2.0.2"
+                    }
+                },
+                "ajv-keywords": {
+                    "version": "5.1.0",
+                    "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+                    "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+                    "dev": true,
+                    "requires": {
+                        "fast-deep-equal": "^3.1.3"
+                    }
+                },
+                "json-schema-traverse": {
+                    "version": "1.0.0",
+                    "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+                    "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+                    "dev": true
+                },
+                "schema-utils": {
+                    "version": "4.3.3",
+                    "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz",
+                    "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
+                    "dev": true,
+                    "requires": {
+                        "@types/json-schema": "^7.0.9",
+                        "ajv": "^8.9.0",
+                        "ajv-formats": "^2.1.1",
+                        "ajv-keywords": "^5.1.0"
+                    }
+                }
             }
         },
         "webpack-bundle-analyzer": {
@@ -26077,9 +26822,9 @@
             "requires": {}
         },
         "webpack-sources": {
-            "version": "3.2.3",
-            "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
-            "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
+            "version": "3.3.3",
+            "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.3.tgz",
+            "integrity": "sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg==",
             "dev": true
         },
         "which": {
@@ -26104,15 +26849,17 @@
             }
         },
         "which-typed-array": {
-            "version": "1.1.15",
-            "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.15.tgz",
-            "integrity": "sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==",
+            "version": "1.1.19",
+            "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
+            "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
             "dev": true,
             "requires": {
                 "available-typed-arrays": "^1.0.7",
-                "call-bind": "^1.0.7",
-                "for-each": "^0.3.3",
-                "gopd": "^1.0.1",
+                "call-bind": "^1.0.8",
+                "call-bound": "^1.0.4",
+                "for-each": "^0.3.5",
+                "get-proto": "^1.0.1",
+                "gopd": "^1.2.0",
                 "has-tostringtag": "^1.0.2"
             }
         },
@@ -26153,9 +26900,9 @@
             }
         },
         "workerpool": {
-            "version": "6.5.1",
-            "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
-            "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
+            "version": "9.3.4",
+            "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-9.3.4.tgz",
+            "integrity": "sha512-TmPRQYYSAnnDiEB0P/Ytip7bFGvqnSU6I2BcuSw7Hx+JSg/DsUi5ebYfc8GYaSdpuvOcEs6dXxPurOYpe9QFwg==",
             "dev": true
         },
         "wrap-ansi": {
diff --git a/package.json b/package.json
index 04b6710a1fa0..9f689b60ff34 100644
--- a/package.json
+++ b/package.json
@@ -2,14 +2,14 @@
     "name": "python",
     "displayName": "Python",
     "description": "Python language support with extension access points for IntelliSense (Pylance), Debugging (Python Debugger), linting, formatting, refactoring, unit tests, and more.",
-    "version": "2025.3.0-dev",
+    "version": "2026.5.0-dev",
     "featureFlags": {
         "usingNewInterpreterStorage": true
     },
     "capabilities": {
         "untrustedWorkspaces": {
-            "supported": "limited",
-            "description": "Only Partial IntelliSense with Pylance is supported. Cannot execute Python with untrusted files."
+            "supported": false,
+            "description": "The Python extension is not available in untrusted workspaces. Use Pylance to get partial IntelliSense support for Python files."
         },
         "virtualWorkspaces": {
             "supported": "limited",
@@ -47,7 +47,7 @@
         "theme": "dark"
     },
     "engines": {
-        "vscode": "^1.94.0-20240918"
+        "vscode": "^1.95.0"
     },
     "enableTelemetry": false,
     "keywords": [
@@ -73,10 +73,18 @@
         "workspaceContains:Pipfile",
         "workspaceContains:setup.py",
         "workspaceContains:requirements.txt",
+        "workspaceContains:pylock.toml",
+        "workspaceContains:**/pylock.*.toml",
         "workspaceContains:manage.py",
         "workspaceContains:app.py",
         "workspaceContains:.venv",
-        "workspaceContains:.conda"
+        "workspaceContains:.conda",
+        "onLanguageModelTool:get_python_environment_details",
+        "onLanguageModelTool:get_python_executable_details",
+        "onLanguageModelTool:install_python_packages",
+        "onLanguageModelTool:configure_python_environment",
+        "onLanguageModelTool:create_virtual_environment",
+        "onTerminalShellIntegration:python"
     ],
     "main": "./out/client/extension",
     "browser": "./dist/extension.browser.js",
@@ -265,6 +273,11 @@
                 "category": "Python",
                 "command": "python.createNewFile"
             },
+            {
+                "category": "Python",
+                "command": "python.copyTestId",
+                "title": "%python.command.python.testing.copyTestId.title%"
+            },
             {
                 "category": "Python",
                 "command": "python.analysis.restartLanguageServer",
@@ -325,7 +338,8 @@
             {
                 "category": "Python",
                 "command": "python.execSelectionInTerminal",
-                "title": "%python.command.python.execSelectionInTerminal.title%"
+                "title": "%python.command.python.execSelectionInTerminal.title%",
+                "shortTitle": "%python.command.python.execSelectionInTerminal.shortTitle%"
             },
             {
                 "category": "Python",
@@ -432,6 +446,16 @@
                     "scope": "resource",
                     "type": "string"
                 },
+                "python.useEnvironmentsExtension": {
+                    "default": false,
+                    "description": "%python.useEnvironmentsExtension.description%",
+                    "scope": "machine-overridable",
+                    "type": "boolean",
+                    "tags": [
+                        "onExP",
+                        "preview"
+                    ]
+                },
                 "python.experiments.enabled": {
                     "default": true,
                     "description": "%python.experiments.enabled.description%",
@@ -448,8 +472,7 @@
                             "pythonPromptNewToolsExt",
                             "pythonTerminalEnvVarActivation",
                             "pythonDiscoveryUsingWorkers",
-                            "pythonTestAdapter",
-                            "pythonREPLSmartSend"
+                            "pythonTestAdapter"
                         ],
                         "enumDescriptions": [
                             "%python.experiments.All.description%",
@@ -457,8 +480,7 @@
                             "%python.experiments.pythonPromptNewToolsExt.description%",
                             "%python.experiments.pythonTerminalEnvVarActivation.description%",
                             "%python.experiments.pythonDiscoveryUsingWorkers.description%",
-                            "%python.experiments.pythonTestAdapter.description%",
-                            "%python.experiments.pythonREPLSmartSend.description%"
+                            "%python.experiments.pythonTestAdapter.description%"
                         ]
                     },
                     "scope": "window",
@@ -475,8 +497,7 @@
                             "pythonPromptNewToolsExt",
                             "pythonTerminalEnvVarActivation",
                             "pythonDiscoveryUsingWorkers",
-                            "pythonTestAdapter",
-                            "pythonREPLSmartSend"
+                            "pythonTestAdapter"
                         ],
                         "enumDescriptions": [
                             "%python.experiments.All.description%",
@@ -484,8 +505,7 @@
                             "%python.experiments.pythonPromptNewToolsExt.description%",
                             "%python.experiments.pythonTerminalEnvVarActivation.description%",
                             "%python.experiments.pythonDiscoveryUsingWorkers.description%",
-                            "%python.experiments.pythonTestAdapter.description%",
-                            "%python.experiments.pythonREPLSmartSend.description%"
+                            "%python.experiments.pythonTestAdapter.description%"
                         ]
                     },
                     "scope": "window",
@@ -621,7 +641,7 @@
                     "type": "array"
                 },
                 "python.terminal.shellIntegration.enabled": {
-                    "default": false,
+                    "default": true,
                     "markdownDescription": "%python.terminal.shellIntegration.enabled.description%",
                     "scope": "resource",
                     "type": "boolean",
@@ -639,11 +659,7 @@
                     "default": false,
                     "description": "%python.REPL.sendToNativeREPL.description%",
                     "scope": "resource",
-                    "type": "boolean",
-                    "tags": [
-                        "onExP",
-                        "preview"
-                    ]
+                    "type": "boolean"
                 },
                 "python.REPL.provideVariables": {
                     "default": true,
@@ -1221,6 +1237,20 @@
                     "command": "python.reportIssue"
                 }
             ],
+            "testing/item/context": [
+                {
+                    "command": "python.copyTestId",
+                    "group": "navigation",
+                    "when": "controllerId == 'python-tests'"
+                }
+            ],
+            "testing/item/gutter": [
+                {
+                    "command": "python.copyTestId",
+                    "group": "navigation",
+                    "when": "controllerId == 'python-tests'"
+                }
+            ],
             "commandPalette": [
                 {
                     "category": "Python",
@@ -1296,6 +1326,12 @@
                     "title": "%python.command.python.execSelectionInTerminal.title%",
                     "when": "!virtualWorkspace && shellExecutionSupported && editorLangId == python"
                 },
+                {
+                    "category": "Python",
+                    "command": "python.copyTestId",
+                    "title": "%python.command.python.testing.copyTestId.title%",
+                    "when": "false"
+                },
                 {
                     "category": "Python",
                     "command": "python.execInREPL",
@@ -1467,6 +1503,160 @@
                 "fileMatch": "meta.yaml",
                 "url": "./schemas/conda-meta.json"
             }
+        ],
+        "languageModelTools": [
+            {
+                "name": "get_python_environment_details",
+                "displayName": "Get Python Environment Info",
+                "userDescription": "%python.languageModelTools.get_python_environment_details.userDescription%",
+                "modelDescription": "This tool will retrieve the details of the Python Environment for the specified file or workspace. The details returned include the 1. Type of Python Environment (conda, venv, etc), 2. Version of Python, 3. List of all installed Python packages with their versions. ALWAYS call configure_python_environment before using this tool. IMPORTANT: This tool is only for Python environments (venv, virtualenv, conda, pipenv, poetry, pyenv, pixi, or any other Python environment manager). Do not use this tool for npm packages, system packages, Ruby gems, or any other non-Python dependencies.",
+                "toolReferenceName": "getPythonEnvironmentInfo",
+                "tags": [
+                    "python",
+                    "python environment",
+                    "extension_installed_by_tool",
+                    "enable_other_tool_configure_python_environment"
+                ],
+                "icon": "$(snake)",
+                "canBeReferencedInPrompt": true,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace to get the environment information for."
+                        }
+                    },
+                    "required": []
+                }
+            },
+            {
+                "name": "get_python_executable_details",
+                "displayName": "Get Python Executable",
+                "userDescription": "%python.languageModelTools.get_python_executable_details.userDescription%",
+                "modelDescription": "This tool will retrieve the details of the Python Environment for the specified file or workspace. ALWAYS use this tool before executing any Python command in the terminal. This tool returns the details of how to construct the fully qualified path and or command including details such as arguments required to run Python in a terminal. Note: Instead of executing `python --version` or `python -c 'import sys; print(sys.executable)'`, use this tool to get the Python executable path to replace the `python` command. E.g. instead of using `python -c 'import sys; print(sys.executable)'`, use this tool to build the command `conda run -n <env_name> -c 'import sys; print(sys.executable)'`. ALWAYS call configure_python_environment before using this tool. IMPORTANT: This tool is only for Python environments (venv, virtualenv, conda, pipenv, poetry, pyenv, pixi, or any other Python environment manager). Do not use this tool for npm packages, system packages, Ruby gems, or any other non-Python dependencies.",
+                "toolReferenceName": "getPythonExecutableCommand",
+                "tags": [
+                    "python",
+                    "python environment",
+                    "extension_installed_by_tool",
+                    "enable_other_tool_configure_python_environment"
+                ],
+                "icon": "$(terminal)",
+                "canBeReferencedInPrompt": true,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace to get the executable information for. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace."
+                        }
+                    },
+                    "required": []
+                }
+            },
+            {
+                "name": "install_python_packages",
+                "displayName": "Install Python Package",
+                "userDescription": "%python.languageModelTools.install_python_packages.userDescription%",
+                "modelDescription": "Installs Python packages in the given workspace. Use this tool to install Python packages in the user's chosen Python environment. ALWAYS call configure_python_environment before using this tool. IMPORTANT: This tool should only be used to install Python packages using package managers like pip or conda (works with any Python environment: venv, virtualenv, pipenv, poetry, pyenv, pixi, conda, etc.). Do not use this tool to install npm packages, system packages (apt/brew/yum), Ruby gems, or any other non-Python dependencies.",
+                "toolReferenceName": "installPythonPackage",
+                "tags": [
+                    "python",
+                    "python environment",
+                    "install python package",
+                    "extension_installed_by_tool",
+                    "enable_other_tool_configure_python_environment"
+                ],
+                "icon": "$(package)",
+                "canBeReferencedInPrompt": true,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "packageList": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            },
+                            "description": "The list of Python packages to install."
+                        },
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace into which the packages are installed. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace."
+                        }
+                    },
+                    "required": [
+                        "packageList"
+                    ]
+                }
+            },
+            {
+                "name": "configure_python_environment",
+                "displayName": "Configure Python Environment",
+                "modelDescription": "This tool configures a Python environment in the given workspace. ALWAYS Use this tool to set up the user's chosen environment and ALWAYS call this tool before using any other Python related tools or running any Python command in the terminal. IMPORTANT: This tool is only for Python environments (venv, virtualenv, conda, pipenv, poetry, pyenv, pixi, or any other Python environment manager). Do not use this tool for npm packages, system packages, Ruby gems, or any other non-Python dependencies.",
+                "userDescription": "%python.languageModelTools.configure_python_environment.userDescription%",
+                "toolReferenceName": "configurePythonEnvironment",
+                "tags": [
+                    "python",
+                    "python environment",
+                    "extension_installed_by_tool"
+                ],
+                "icon": "$(gear)",
+                "canBeReferencedInPrompt": true,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace for which a Python Environment needs to be configured."
+                        }
+                    },
+                    "required": []
+                }
+            },
+            {
+                "name": "create_virtual_environment",
+                "displayName": "Create a Virtual Environment",
+                "modelDescription": "This tool will create a Virual Environment",
+                "tags": [],
+                "canBeReferencedInPrompt": false,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "packageList": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            },
+                            "description": "The list of packages to install."
+                        },
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace for which a Python Environment needs to be configured."
+                        }
+                    },
+                    "required": []
+                },
+                "when": "false"
+            },
+            {
+                "name": "selectEnvironment",
+                "displayName": "Select a Python Environment",
+                "modelDescription": "This tool will prompt the user to select an existing Python Environment",
+                "tags": [],
+                "canBeReferencedInPrompt": false,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace for which a Python Environment needs to be configured."
+                        }
+                    },
+                    "required": []
+                },
+                "when": "false"
+            }
         ]
     },
     "copilot": {
@@ -1505,6 +1695,9 @@
         "lint-fix": "eslint --fix src build pythonExtensionApi gulpfile.js",
         "format-check": "prettier --check 'src/**/*.ts' 'build/**/*.js' '.github/**/*.yml' gulpfile.js",
         "format-fix": "prettier --write 'src/**/*.ts' 'build/**/*.js' '.github/**/*.yml' gulpfile.js",
+        "check-python": "npm run check-python:ruff && npm run check-python:pyright",
+        "check-python:ruff": "cd python_files && python -m pip install -U ruff && python -m ruff check . && python -m ruff format --check",
+        "check-python:pyright": "cd python_files && npx --yes pyright@1.1.308 .",
         "clean": "gulp clean",
         "addExtensionPackDependencies": "gulp addExtensionPackDependencies",
         "updateBuildNumber": "gulp updateBuildNumber",
@@ -1512,7 +1705,7 @@
         "webpack": "webpack"
     },
     "dependencies": {
-        "@iarna/toml": "^2.2.5",
+        "@iarna/toml": "^3.0.0",
         "@vscode/extension-telemetry": "^0.8.4",
         "arch": "^2.1.0",
         "fs-extra": "^11.2.0",
@@ -1520,8 +1713,8 @@
         "iconv-lite": "^0.6.3",
         "inversify": "^6.0.2",
         "jsonc-parser": "^3.0.0",
-        "lodash": "^4.17.21",
-        "minimatch": "^5.0.1",
+        "lodash": "^4.18.1",
+        "minimatch": "^5.1.8",
         "named-js-regexp": "^1.3.3",
         "node-stream-zip": "^1.6.0",
         "reflect-metadata": "^0.2.2",
@@ -1530,7 +1723,7 @@
         "semver": "^7.5.2",
         "stack-trace": "0.0.10",
         "sudo-prompt": "^9.2.1",
-        "tmp": "^0.0.33",
+        "tmp": "^0.2.5",
         "uint64be": "^3.0.0",
         "unicode": "^14.0.0",
         "vscode-debugprotocol": "^1.28.0",
@@ -1553,13 +1746,13 @@
         "@types/glob": "^7.2.0",
         "@types/lodash": "^4.14.104",
         "@types/mocha": "^9.1.0",
-        "@types/node": "^22.5.0",
+        "@types/node": "^22.19.1",
         "@types/semver": "^5.5.0",
         "@types/shortid": "^0.0.29",
         "@types/sinon": "^17.0.3",
         "@types/stack-trace": "0.0.29",
         "@types/tmp": "^0.0.33",
-        "@types/vscode": "^1.93.0",
+        "@types/vscode": "^1.95.0",
         "@types/which": "^2.0.1",
         "@types/winreg": "^1.2.30",
         "@types/xml2js": "^0.4.2",
@@ -1606,8 +1799,8 @@
         "tsconfig-paths-webpack-plugin": "^3.2.0",
         "typemoq": "^2.1.0",
         "typescript": "~5.2",
-        "uuid": "^8.3.2",
-        "webpack": "^5.76.0",
+        "uuid": "^14.0.0",
+        "webpack": "^5.105.0",
         "webpack-bundle-analyzer": "^4.5.0",
         "webpack-cli": "^4.9.2",
         "webpack-fix-default-import-plugin": "^1.0.3",
diff --git a/package.nls.json b/package.nls.json
index 8bff60a4b07d..57f2ed95b2c0 100644
--- a/package.nls.json
+++ b/package.nls.json
@@ -1,5 +1,9 @@
 {
     "python.command.python.startTerminalREPL.title": "Start Terminal REPL",
+    "python.languageModelTools.get_python_environment_details.userDescription": "Get information for a Python Environment, such as Type, Version, Packages, and more.",
+    "python.languageModelTools.install_python_packages.userDescription": "Installs Python packages in a Python Environment.",
+    "python.languageModelTools.get_python_executable_details.userDescription": "Get executable info for a Python Environment",
+    "python.languageModelTools.configure_python_environment.userDescription": "Configure a Python Environment for a workspace",
     "python.command.python.startNativeREPL.title": "Start Native Python REPL",
     "python.command.python.createEnvironment.title": "Create Environment...",
     "python.command.python.createNewFile.title": "New Python File",
@@ -15,6 +19,7 @@
     "python.command.python.configureTests.title": "Configure Tests",
     "python.command.testing.rerunFailedTests.title": "Rerun Failed Tests",
     "python.command.python.execSelectionInTerminal.title": "Run Selection/Line in Python Terminal",
+    "python.command.python.execSelectionInTerminal.shortTitle": "Run Selection/Line",
     "python.command.python.execInREPL.title": "Run Selection/Line in Native Python REPL",
     "python.command.python.execSelectionInDjangoShell.title": "Run Selection/Line in Django Shell",
     "python.command.python.reportIssue.title": "Report Issue...",
@@ -22,6 +27,7 @@
     "python.command.python.analysis.restartLanguageServer.title": "Restart Language Server",
     "python.command.python.launchTensorBoard.title": "Launch TensorBoard",
     "python.command.python.refreshTensorBoard.title": "Refresh TensorBoard",
+    "python.command.python.testing.copyTestId.title": "Copy Test Id",
     "python.createEnvironment.contentButton.description": "Show or hide Create Environment button in the editor for `requirements.txt` or other dependency files.",
     "python.createEnvironment.trigger.description": "Detect if environment creation is required for the current project",
     "python.menu.createNewFile.title": "Python File",
@@ -33,6 +39,7 @@
     "python.debugger.deprecatedMessage": "This configuration will be deprecated soon. Please replace `python` with `debugpy` to use the new Python Debugger extension.",
     "python.defaultInterpreterPath.description": "Path to default Python to use when extension loads up for the first time, no longer used once an interpreter is selected for the workspace. See [here](https://aka.ms/AAfekmf) to understand when this is used",
     "python.envFile.description": "Absolute path to a file containing environment variable definitions.",
+    "python.useEnvironmentsExtension.description": "Enables the Python Environments extension. Requires window reload on change.",
     "python.experiments.enabled.description": "Enables A/B tests experiments in the Python extension. If enabled, you may get included in proposed enhancements and/or features.",
     "python.experiments.optInto.description": "List of experiments to opt into. If empty, user is assigned the default experiment groups. See [here](https://github.com/microsoft/vscode-python/wiki/AB-Experiments) for more details.",
     "python.experiments.optOutFrom.description": "List of experiments to opt out of. If empty, user is assigned the default experiment groups. See [here](https://github.com/microsoft/vscode-python/wiki/AB-Experiments) for more details.",
@@ -42,7 +49,6 @@
     "python.experiments.pythonTerminalEnvVarActivation.description": "Enables use of environment variables to activate terminals instead of sending activation commands.",
     "python.experiments.pythonDiscoveryUsingWorkers.description": "Enables use of worker threads to do heavy computation when discovering interpreters.",
     "python.experiments.pythonTestAdapter.description": "Denotes the Python Test Adapter experiment.",
-    "python.experiments.pythonREPLSmartSend.description": "Denotes the Python REPL Smart Send experiment.",
     "python.experiments.pythonRecommendTensorboardExt.description": "Denotes the Tensorboard Extension recommendation experiment.",
     "python.globalModuleInstallation.description": "Whether to install Python modules globally when not using an environment.",
     "python.languageServer.description": "Defines type of the language server.",
@@ -67,7 +73,7 @@
     "python.tensorBoard.logDirectory.description": "Set this setting to your preferred TensorBoard log directory to skip log directory prompt when starting TensorBoard.",
     "python.tensorBoard.logDirectory.markdownDeprecationMessage": "Tensorboard support has been moved to the extension [Tensorboard extension](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.tensorboard). Instead use the setting `tensorBoard.logDirectory`.",
     "python.tensorBoard.logDirectory.deprecationMessage": "Tensorboard support has been moved to the extension Tensorboard extension. Instead use the setting `tensorBoard.logDirectory`.",
-    "python.terminal.shellIntegration.enabled.description": "Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) for the terminals running python. Shell integration enhances the terminal experience by enabling command decorations, run recent command, improving accessibility among other things.",
+    "python.terminal.shellIntegration.enabled.description": "Enable [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) for the terminals running python. Shell integration enhances the terminal experience by enabling command decorations, run recent command, improving accessibility among other things. Note: PyREPL (available in Python 3.13+) is automatically disabled when shell integration is enabled to avoid cursor indentation issues.",
     "python.terminal.activateEnvInCurrentTerminal.description": "Activate Python Environment in the current Terminal on load of the Extension.",
     "python.terminal.activateEnvironment.description": "Activate Python Environment in all Terminals created.",
     "python.terminal.executeInFileDir.description": "When executing a file in the terminal, whether to use execute in the file's directory, instead of the current open folder.",
@@ -87,7 +93,7 @@
     "python.venvPath.description": "Path to folder with a list of Virtual Environments (e.g. ~/.pyenv, ~/Envs, ~/.virtualenvs).",
     "walkthrough.pythonWelcome.title": "Get Started with Python Development",
     "walkthrough.pythonWelcome.description": "Your first steps to set up a Python project with all the powerful tools and features that the Python extension has to offer!",
-     "walkthrough.step.python.createPythonFile.title": "Create a Python file",
+    "walkthrough.step.python.createPythonFile.title": "Create a Python file",
     "walkthrough.step.python.createPythonFolder.title": "Open a Python project folder",
     "walkthrough.step.python.createPythonFile.description": {
         "message": "[Open](command:toSide:workbench.action.files.openFile) or [create](command:toSide:workbench.action.files.newUntitledFile?%7B%22languageId%22%3A%22python%22%7D) a Python file - make sure to save it as \".py\".\n[Create Python File](command:toSide:workbench.action.files.newUntitledFile?%7B%22languageId%22%3A%22python%22%7D)",
@@ -99,7 +105,7 @@
     },
     "walkthrough.step.python.createPythonFolder.description": {
         "message": "[Open](command:workbench.action.files.openFolder) or create a project folder.\n[Open Project Folder](command:workbench.action.files.openFolder)",
-        "comment":  [
+        "comment": [
             "{Locked='](command:workbench.action.files.openFolder'}",
             "Do not translate the 'command:*' part inside of the '(..)'. It is an internal command syntax for VS Code",
             "Please make sure there is no space between the right bracket and left parenthesis:  ]( this is an internal syntax for links"
@@ -129,7 +135,7 @@
     "walkthrough.step.python.createEnvironment.title": "Select or create a Python environment",
     "walkthrough.step.python.createEnvironment.description": {
         "message": "Create an environment for your Python project or use [Select Python Interpreter](command:python.setInterpreter) to select an existing one.\n[Create Environment](command:python.createEnvironment)\n**Tip**: Run the ``Python: Create Environment`` command in the [Command Palette](command:workbench.action.showCommands).",
-        "comment":  [
+        "comment": [
             "{Locked='](command:python.createEnvironment'}",
             "{Locked='](command:workbench.action.showCommands'}",
             "{Locked='](command:python.setInterpreter'}",
@@ -141,8 +147,8 @@
     "walkthrough.step.python.runAndDebug.description": "Open your Python file  and click on the play button on the top right of the editor, or press F5 when on the file and select \"Python File\" to run with the debugger. \n  \n[Learn more](https://code.visualstudio.com/docs/python/python-tutorial#_run-hello-world)",
     "walkthrough.step.python.learnMoreWithDS.title": "Keep exploring!",
     "walkthrough.step.python.learnMoreWithDS.description": {
-        "message":"🎨 Explore all the features the Python extension has to offer by looking for \"Python\" in the [Command Palette](command:workbench.action.showCommands). \n 📈 Learn more about getting started with [data science](command:workbench.action.openWalkthrough?%7B%22category%22%3A%22ms-python.python%23pythonDataScienceWelcome%22%2C%22step%22%3A%22ms-python.python%23python.createNewNotebook%22%7D) in Python. \n ✨ Take a look at our [Release Notes](https://aka.ms/AA8dxtb) to learn more about the latest features. \n \n[Follow along with the Python Tutorial](https://aka.ms/AA8dqti)",
-        "comment":[
+        "message": "🎨 Explore all the features the Python extension has to offer by looking for \"Python\" in the [Command Palette](command:workbench.action.showCommands). \n 📈 Learn more about getting started with [data science](command:workbench.action.openWalkthrough?%7B%22category%22%3A%22ms-python.python%23pythonDataScienceWelcome%22%2C%22step%22%3A%22ms-python.python%23python.createNewNotebook%22%7D) in Python. \n ✨ Take a look at our [Release Notes](https://aka.ms/AA8dxtb) to learn more about the latest features. \n \n[Follow along with the Python Tutorial](https://aka.ms/AA8dqti)",
+        "comment": [
             "{Locked='](command:workbench.action.showCommands'}",
             "{Locked='](command:workbench.action.openWalkthrough?%7B%22category%22%3A%22ms-python.python%23pythonDataScienceWelcome%22%2C%22step%22%3A%22ms-python.python%23python.createNewNotebook%22%7D'}",
             "Do not translate the 'command:*' part inside of the '(..)'. It is an internal command syntax for VS Code",
diff --git a/pythonExtensionApi/package-lock.json b/pythonExtensionApi/package-lock.json
index ad49ed836900..e462fc1c888a 100644
--- a/pythonExtensionApi/package-lock.json
+++ b/pythonExtensionApi/package-lock.json
@@ -14,7 +14,7 @@
                 "typescript": "~5.2"
             },
             "engines": {
-                "node": ">=20.18.0",
+                "node": ">=22.17.0",
                 "vscode": "^1.93.0"
             }
         },
diff --git a/pythonExtensionApi/package.json b/pythonExtensionApi/package.json
index d7d976642bb3..11e0445aa8da 100644
--- a/pythonExtensionApi/package.json
+++ b/pythonExtensionApi/package.json
@@ -13,7 +13,7 @@
     "main": "./out/main.js",
     "types": "./out/main.d.ts",
     "engines": {
-        "node": ">=20.18.0",
+        "node": ">=22.21.1",
         "vscode": "^1.93.0"
     },
     "license": "MIT",
@@ -27,7 +27,7 @@
     },
     "devDependencies": {
         "typescript": "~5.2",
-        "@types/vscode": "^1.93.0",
+        "@types/vscode": "^1.102.0",
         "source-map": "^0.8.0-beta.0"
     },
     "scripts": {
diff --git a/python_files/create_venv.py b/python_files/create_venv.py
index fd1ff9ab1a47..83106bd889f8 100644
--- a/python_files/create_venv.py
+++ b/python_files/create_venv.py
@@ -98,11 +98,20 @@ def run_process(args: Sequence[str], error_message: str) -> None:
         raise VenvError(error_message) from exc
 
 
+def get_win_venv_path(name: str) -> str:
+    venv_dir = CWD / name
+    # If using MSYS2 Python, the Python executable is located in the 'bin' directory.
+    if file_exists(venv_dir / "bin" / "python.exe"):
+        return os.fspath(venv_dir / "bin" / "python.exe")
+    else:
+        return os.fspath(venv_dir / "Scripts" / "python.exe")
+
+
 def get_venv_path(name: str) -> str:
     # See `venv` doc here for more details on binary location:
     # https://docs.python.org/3/library/venv.html#creating-virtual-environments
     if sys.platform == "win32":
-        return os.fspath(CWD / name / "Scripts" / "python.exe")
+        return get_win_venv_path(name)
     else:
         return os.fspath(CWD / name / "bin" / "python")
 
diff --git a/python_files/jedilsp_requirements/requirements.in b/python_files/jedilsp_requirements/requirements.in
index 8bafda64375e..794e9c8ea686 100644
--- a/python_files/jedilsp_requirements/requirements.in
+++ b/python_files/jedilsp_requirements/requirements.in
@@ -1,8 +1,8 @@
 # This file is used to generate requirements.txt.
 # To update requirements.txt, run the following commands.
-# Use Python 3.8 when creating the environment or using pip-tools
+# Use Python 3.9 when creating the environment or using pip-tools
 # 1) Install `uv` https://docs.astral.sh/uv/getting-started/installation/
-# 2) uv pip compile --generate-hashes --upgrade python_files\jedilsp_requirements\requirements.in > python_files\jedilsp_requirements\requirements.txt
+# 2) uv pip compile --generate-hashes --upgrade python_files\jedilsp_requirements\requirements.in -o python_files\jedilsp_requirements\requirements.txt
 
 jedi-language-server>=0.34.3
 pygls>=0.10.3
diff --git a/python_files/jedilsp_requirements/requirements.txt b/python_files/jedilsp_requirements/requirements.txt
index ef4c7e1de6ae..e2599e7bbce4 100644
Binary files a/python_files/jedilsp_requirements/requirements.txt and b/python_files/jedilsp_requirements/requirements.txt differ
diff --git a/python_files/printEnvVariablesToFile.py b/python_files/printEnvVariablesToFile.py
index eae01b3d073c..f6013a8c24cf 100644
--- a/python_files/printEnvVariablesToFile.py
+++ b/python_files/printEnvVariablesToFile.py
@@ -12,5 +12,5 @@
     raise ValueError("Missing output file argument")
 
 with open(output_file, "w") as outfile:  # noqa: PTH123
-    for key, val in os.environ.items():
+    for key, val in os.environ.items():  # noqa: FURB122
         outfile.write(f"{key}={val}\n")
diff --git a/python_files/python_server.py b/python_files/python_server.py
index 1689d9b8f7f9..e7ee92794a21 100644
--- a/python_files/python_server.py
+++ b/python_files/python_server.py
@@ -5,6 +5,7 @@
 import sys
 import traceback
 import uuid
+from pathlib import Path
 from typing import Dict, List, Optional, Union
 
 STDIN = sys.stdin
@@ -63,6 +64,9 @@ def custom_input(prompt=""):
             message_text = STDIN.buffer.read(content_length).decode()
             message_json = json.loads(message_text)
             return message_json["result"]["userInput"]
+    except EOFError:
+        # Input stream closed, exit gracefully
+        sys.exit(0)
     except Exception:
         print_log(traceback.format_exc())
 
@@ -73,7 +77,7 @@ def custom_input(prompt=""):
 
 
 def handle_response(request_id):
-    while not STDIN.closed:
+    while True:
         try:
             headers = get_headers()
             # Content-Length is the data size in bytes.
@@ -87,8 +91,10 @@ def handle_response(request_id):
                     send_response(our_user_input, message_json["id"])
                 elif message_json["method"] == "exit":
                     sys.exit(0)
-
-        except Exception:  # noqa: PERF203
+        except EOFError:  # noqa: PERF203
+            # Input stream closed, exit gracefully
+            sys.exit(0)
+        except Exception:
             print_log(traceback.format_exc())
 
 
@@ -163,7 +169,11 @@ def get_value(self) -> str:
 def get_headers():
     headers = {}
     while True:
-        line = STDIN.buffer.readline().decode().strip()
+        raw = STDIN.buffer.readline()
+        # Detect EOF: readline() returns empty bytes when input stream is closed
+        if raw == b"":
+            raise EOFError("EOF reached while reading headers")
+        line = raw.decode().strip()
         if not line:
             break
         name, value = line.split(":", 1)
@@ -172,7 +182,17 @@ def get_headers():
 
 
 if __name__ == "__main__":
-    while not STDIN.closed:
+    # https://docs.python.org/3/tutorial/modules.html#the-module-search-path
+    # The directory containing the input script (or the current directory when no file is specified).
+    # Here we emulate the same behavior like no file is specified.
+    input_script_dir = Path(__file__).parent
+    script_dir_str = str(input_script_dir)
+    if script_dir_str in sys.path:
+        sys.path.remove(script_dir_str)
+    while "" in sys.path:
+        sys.path.remove("")
+    sys.path.insert(0, "")
+    while True:
         try:
             headers = get_headers()
             # Content-Length is the data size in bytes.
@@ -187,6 +207,8 @@ def get_headers():
                     check_valid_command(request_json)
                 elif request_json["method"] == "exit":
                     sys.exit(0)
-
-        except Exception:  # noqa: PERF203
+        except EOFError:  # noqa: PERF203
+            # Input stream closed (VS Code terminated), exit gracefully
+            sys.exit(0)
+        except Exception:
             print_log(traceback.format_exc())
diff --git a/python_files/pythonrc.py b/python_files/pythonrc.py
index 0f552c86d375..3042ffb7a309 100644
--- a/python_files/pythonrc.py
+++ b/python_files/pythonrc.py
@@ -5,7 +5,6 @@
     import readline
 
 original_ps1 = ">>> "
-use_shell_integration = sys.version_info < (3, 13)
 is_wsl = "microsoft-standard-WSL" in platform.release()
 
 
@@ -53,13 +52,15 @@ def __str__(self):
         result = ""
         # For non-windows allow recent_command history.
         if sys.platform != "win32":
-            result = "{command_line}{command_finished}{prompt_started}{prompt}{command_start}{command_executed}".format(
+            result = "{soh}{command_executed}{command_line}{command_finished}{prompt_started}{stx}{prompt}{soh}{command_start}{stx}".format(
+                soh="\001",
+                stx="\002",
+                command_executed="\x1b]633;C\x07",
                 command_line="\x1b]633;E;" + str(get_last_command()) + "\x07",
                 command_finished="\x1b]633;D;" + str(exit_code) + "\x07",
                 prompt_started="\x1b]633;A\x07",
                 prompt=original_ps1,
                 command_start="\x1b]633;B\x07",
-                command_executed="\x1b]633;C\x07",
             )
         else:
             result = "{command_finished}{prompt_started}{prompt}{command_start}{command_executed}".format(
@@ -74,8 +75,11 @@ def __str__(self):
 
         return result
 
+    def __repr__(self):
+        return "<Custom PS1 for VS Code Python Shell Integration>"
+
 
-if sys.platform != "win32" and (not is_wsl) and use_shell_integration:
+if sys.platform != "win32" and (not is_wsl):
     sys.ps1 = PS1()
 
 if sys.platform == "darwin":
diff --git a/python_files/tests/pytestadapter/.data/2496-black-formatter/app.py b/python_files/tests/pytestadapter/.data/2496-black-formatter/app.py
new file mode 100644
index 000000000000..3b474e9d911e
--- /dev/null
+++ b/python_files/tests/pytestadapter/.data/2496-black-formatter/app.py
@@ -0,0 +1,6 @@
+def add(a, b):
+    return a + b
+
+
+def subtract(a, b):
+    return a - b
diff --git a/python_files/tests/pytestadapter/.data/2496-black-formatter/test_app.py b/python_files/tests/pytestadapter/.data/2496-black-formatter/test_app.py
new file mode 100644
index 000000000000..ef4398feb786
--- /dev/null
+++ b/python_files/tests/pytestadapter/.data/2496-black-formatter/test_app.py
@@ -0,0 +1,14 @@
+import pytest
+from app import add, subtract
+
+
+def test_add(): # test_marker--test_add
+    assert add(2, 3) == 5
+    assert add(-1, 1) == 0
+    assert add(0, 0) == 0
+
+
+def test_subtract(): # test_marker--test_subtract
+    assert subtract(5, 3) == 2
+    assert subtract(0, 0) == 0
+    assert subtract(-1, -1) == 0
diff --git a/python_files/tests/pytestadapter/expected_discovery_test_output.py b/python_files/tests/pytestadapter/expected_discovery_test_output.py
index d7e82acc6890..047f1c72ad17 100644
--- a/python_files/tests/pytestadapter/expected_discovery_test_output.py
+++ b/python_files/tests/pytestadapter/expected_discovery_test_output.py
@@ -1,6 +1,11 @@
 import os
 
-from .helpers import TEST_DATA_PATH, find_test_line_number, get_absolute_test_id
+from .helpers import (
+    TEST_DATA_PATH,
+    find_class_line_number,
+    find_test_line_number,
+    get_absolute_test_id,
+)
 
 # This file contains the expected output dictionaries for tests discovery and is used in test_discovery.py.
 
@@ -91,7 +96,11 @@
                             ),
                         }
                     ],
-                    "id_": "unittest_pytest_same_file.py::TestExample",
+                    "id_": get_absolute_test_id(
+                        "unittest_pytest_same_file.py::TestExample",
+                        unit_pytest_same_file_path,
+                    ),
+                    "lineno": find_class_line_number("TestExample", unit_pytest_same_file_path),
                 },
                 {
                     "name": "test_true_pytest",
@@ -200,7 +209,11 @@
                                     ),
                                 },
                             ],
-                            "id_": "unittest_folder/test_add.py::TestAddFunction",
+                            "id_": get_absolute_test_id(
+                                "unittest_folder/test_add.py::TestAddFunction",
+                                test_add_path,
+                            ),
+                            "lineno": find_class_line_number("TestAddFunction", test_add_path),
                         },
                         {
                             "name": "TestDuplicateFunction",
@@ -225,7 +238,13 @@
                                     ),
                                 },
                             ],
-                            "id_": "unittest_folder/test_add.py::TestDuplicateFunction",
+                            "id_": get_absolute_test_id(
+                                "unittest_folder/test_add.py::TestDuplicateFunction",
+                                test_add_path,
+                            ),
+                            "lineno": find_class_line_number(
+                                "TestDuplicateFunction", test_add_path
+                            ),
                         },
                     ],
                 },
@@ -275,7 +294,13 @@
                                     ),
                                 },
                             ],
-                            "id_": "unittest_folder/test_subtract.py::TestSubtractFunction",
+                            "id_": get_absolute_test_id(
+                                "unittest_folder/test_subtract.py::TestSubtractFunction",
+                                test_subtract_path,
+                            ),
+                            "lineno": find_class_line_number(
+                                "TestSubtractFunction", test_subtract_path
+                            ),
                         },
                         {
                             "name": "TestDuplicateFunction",
@@ -300,7 +325,13 @@
                                     ),
                                 },
                             ],
-                            "id_": "unittest_folder/test_subtract.py::TestDuplicateFunction",
+                            "id_": get_absolute_test_id(
+                                "unittest_folder/test_subtract.py::TestDuplicateFunction",
+                                test_subtract_path,
+                            ),
+                            "lineno": find_class_line_number(
+                                "TestDuplicateFunction", test_subtract_path
+                            ),
                         },
                     ],
                 },
@@ -534,7 +565,11 @@
                     "name": "TestClass",
                     "path": os.fspath(parameterize_tests_path),
                     "type_": "class",
-                    "id_": "parametrize_tests.py::TestClass",
+                    "id_": get_absolute_test_id(
+                        "parametrize_tests.py::TestClass",
+                        parameterize_tests_path,
+                    ),
+                    "lineno": find_class_line_number("TestClass", parameterize_tests_path),
                     "children": [
                         {
                             "name": "test_adding",
@@ -907,13 +942,23 @@
                     "name": "TestFirstClass",
                     "path": str(TEST_MULTI_CLASS_NEST_PATH),
                     "type_": "class",
-                    "id_": "test_multi_class_nest.py::TestFirstClass",
+                    "id_": get_absolute_test_id(
+                        "test_multi_class_nest.py::TestFirstClass",
+                        TEST_MULTI_CLASS_NEST_PATH,
+                    ),
+                    "lineno": find_class_line_number("TestFirstClass", TEST_MULTI_CLASS_NEST_PATH),
                     "children": [
                         {
                             "name": "TestSecondClass",
                             "path": str(TEST_MULTI_CLASS_NEST_PATH),
                             "type_": "class",
-                            "id_": "test_multi_class_nest.py::TestFirstClass::TestSecondClass",
+                            "id_": get_absolute_test_id(
+                                "test_multi_class_nest.py::TestFirstClass::TestSecondClass",
+                                TEST_MULTI_CLASS_NEST_PATH,
+                            ),
+                            "lineno": find_class_line_number(
+                                "TestSecondClass", TEST_MULTI_CLASS_NEST_PATH
+                            ),
                             "children": [
                                 {
                                     "name": "test_second",
@@ -954,7 +999,13 @@
                             "name": "TestSecondClass2",
                             "path": str(TEST_MULTI_CLASS_NEST_PATH),
                             "type_": "class",
-                            "id_": "test_multi_class_nest.py::TestFirstClass::TestSecondClass2",
+                            "id_": get_absolute_test_id(
+                                "test_multi_class_nest.py::TestFirstClass::TestSecondClass2",
+                                TEST_MULTI_CLASS_NEST_PATH,
+                            ),
+                            "lineno": find_class_line_number(
+                                "TestSecondClass2", TEST_MULTI_CLASS_NEST_PATH
+                            ),
                             "children": [
                                 {
                                     "name": "test_second2",
@@ -1196,7 +1247,13 @@
                             + "::TestNotEmpty::test_string",
                         },
                     ],
-                    "id_": "same_function_new_class_param.py::TestNotEmpty",
+                    "id_": get_absolute_test_id(
+                        "same_function_new_class_param.py::TestNotEmpty",
+                        TEST_DATA_PATH / "same_function_new_class_param.py",
+                    ),
+                    "lineno": find_class_line_number(
+                        "TestNotEmpty", TEST_DATA_PATH / "same_function_new_class_param.py"
+                    ),
                 },
                 {
                     "name": "TestEmpty",
@@ -1264,7 +1321,13 @@
                             + "::TestEmpty::test_string",
                         },
                     ],
-                    "id_": "same_function_new_class_param.py::TestEmpty",
+                    "id_": get_absolute_test_id(
+                        "same_function_new_class_param.py::TestEmpty",
+                        TEST_DATA_PATH / "same_function_new_class_param.py",
+                    ),
+                    "lineno": find_class_line_number(
+                        "TestEmpty", TEST_DATA_PATH / "same_function_new_class_param.py"
+                    ),
                 },
             ],
         }
@@ -1334,7 +1397,13 @@
                             ),
                         }
                     ],
-                    "id_": "test_param_span_class.py::TestClass1",
+                    "id_": get_absolute_test_id(
+                        "test_param_span_class.py::TestClass1",
+                        TEST_DATA_PATH / "test_param_span_class.py",
+                    ),
+                    "lineno": find_class_line_number(
+                        "TestClass1", TEST_DATA_PATH / "test_param_span_class.py"
+                    ),
                 },
                 {
                     "name": "TestClass2",
@@ -1387,7 +1456,13 @@
                             ),
                         }
                     ],
-                    "id_": "test_param_span_class.py::TestClass2",
+                    "id_": get_absolute_test_id(
+                        "test_param_span_class.py::TestClass2",
+                        TEST_DATA_PATH / "test_param_span_class.py",
+                    ),
+                    "lineno": find_class_line_number(
+                        "TestClass2", TEST_DATA_PATH / "test_param_span_class.py"
+                    ),
                 },
             ],
         }
@@ -1460,7 +1535,11 @@
                                     ),
                                 },
                             ],
-                            "id_": "pytest_describe_plugin/describe_only.py::describe_A",
+                            "id_": get_absolute_test_id(
+                                "pytest_describe_plugin/describe_only.py::describe_A",
+                                describe_only_path,
+                            ),
+                            "lineno": find_class_line_number("describe_A", describe_only_path),
                         }
                     ],
                 }
@@ -1540,7 +1619,13 @@
                                             ),
                                         },
                                     ],
-                                    "id_": "pytest_describe_plugin/nested_describe.py::describe_list::describe_append",
+                                    "id_": get_absolute_test_id(
+                                        "pytest_describe_plugin/nested_describe.py::describe_list::describe_append",
+                                        nested_describe_path,
+                                    ),
+                                    "lineno": find_class_line_number(
+                                        "describe_append", nested_describe_path
+                                    ),
                                 },
                                 {
                                     "name": "describe_remove",
@@ -1565,10 +1650,20 @@
                                             ),
                                         }
                                     ],
-                                    "id_": "pytest_describe_plugin/nested_describe.py::describe_list::describe_remove",
+                                    "id_": get_absolute_test_id(
+                                        "pytest_describe_plugin/nested_describe.py::describe_list::describe_remove",
+                                        nested_describe_path,
+                                    ),
+                                    "lineno": find_class_line_number(
+                                        "describe_remove", nested_describe_path
+                                    ),
                                 },
                             ],
-                            "id_": "pytest_describe_plugin/nested_describe.py::describe_list",
+                            "id_": get_absolute_test_id(
+                                "pytest_describe_plugin/nested_describe.py::describe_list",
+                                nested_describe_path,
+                            ),
+                            "lineno": find_class_line_number("describe_list", nested_describe_path),
                         }
                     ],
                 }
@@ -1668,3 +1763,321 @@
     ],
     "id_": TEST_DATA_PATH_STR,
 }
+
+# This is the expected output for the 2496-black-formatter folder when run with black plugin
+# └── .data
+#    └── 2496-black-formatter
+#       └── app.py
+#          └── black
+#       └── test_app.py
+#          └── black
+#          └── test_add
+#          └── test_subtract
+black_formatter_folder_path = TEST_DATA_PATH / "2496-black-formatter"
+black_app_path = black_formatter_folder_path / "app.py"
+black_test_app_path = black_formatter_folder_path / "test_app.py"
+black_formatter_expected_output = {
+    "name": ".data",
+    "path": TEST_DATA_PATH_STR,
+    "type_": "folder",
+    "children": [
+        {
+            "name": "2496-black-formatter",
+            "path": os.fspath(black_formatter_folder_path),
+            "type_": "folder",
+            "id_": os.fspath(black_formatter_folder_path),
+            "children": [
+                {
+                    "name": "app.py",
+                    "path": os.fspath(black_app_path),
+                    "type_": "file",
+                    "id_": os.fspath(black_app_path),
+                    "children": [
+                        {
+                            "name": "black",
+                            "path": os.fspath(black_app_path),
+                            "lineno": "0",
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "2496-black-formatter/app.py::black",
+                                black_app_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "2496-black-formatter/app.py::black",
+                                black_app_path,
+                            ),
+                        }
+                    ],
+                },
+                {
+                    "name": "test_app.py",
+                    "path": os.fspath(black_test_app_path),
+                    "type_": "file",
+                    "id_": os.fspath(black_test_app_path),
+                    "children": [
+                        {
+                            "name": "black",
+                            "path": os.fspath(black_test_app_path),
+                            "lineno": "0",
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "2496-black-formatter/test_app.py::black",
+                                black_test_app_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "2496-black-formatter/test_app.py::black",
+                                black_test_app_path,
+                            ),
+                        },
+                        {
+                            "name": "test_add",
+                            "path": os.fspath(black_test_app_path),
+                            "lineno": find_test_line_number(
+                                "test_add",
+                                black_test_app_path,
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "2496-black-formatter/test_app.py::test_add",
+                                black_test_app_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "2496-black-formatter/test_app.py::test_add",
+                                black_test_app_path,
+                            ),
+                        },
+                        {
+                            "name": "test_subtract",
+                            "path": os.fspath(black_test_app_path),
+                            "lineno": find_test_line_number(
+                                "test_subtract",
+                                black_test_app_path,
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "2496-black-formatter/test_app.py::test_subtract",
+                                black_test_app_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "2496-black-formatter/test_app.py::test_subtract",
+                                black_test_app_path,
+                            ),
+                        },
+                    ],
+                },
+            ],
+        }
+    ],
+    "id_": TEST_DATA_PATH_STR,
+}
+
+# =====================================================================================
+# PROJECT_ROOT_PATH environment variable tests
+# These test the project-based testing feature where PROJECT_ROOT_PATH changes
+# the test tree root from cwd to the specified project path.
+# =====================================================================================
+
+# This is the expected output for unittest_folder when PROJECT_ROOT_PATH is set to unittest_folder.
+# The root of the tree is unittest_folder (not .data), simulating project-based testing.
+#
+# **Project Configuration:**
+# In the VS Code Python extension, projects are defined by the Python Environments extension.
+# Each project has a root directory (identified by pyproject.toml, setup.py, etc.).
+# When PROJECT_ROOT_PATH is set, pytest uses that path as the test tree root instead of cwd.
+#
+# **Test Tree Structure:**
+# Without PROJECT_ROOT_PATH (legacy mode):
+#   └── .data (cwd = workspace root)
+#       └── unittest_folder
+#           └── test_add.py, test_subtract.py...
+#
+# With PROJECT_ROOT_PATH set to unittest_folder (project-based mode):
+#   └── unittest_folder (ROOT - set via PROJECT_ROOT_PATH env var)
+#       ├── test_add.py
+#       │   └── TestAddFunction
+#       │       ├── test_add_negative_numbers
+#       │       └── test_add_positive_numbers
+#       │   └── TestDuplicateFunction
+#       │       └── test_dup_a
+#       └── test_subtract.py
+#           └── TestSubtractFunction
+#               ├── test_subtract_negative_numbers
+#               └── test_subtract_positive_numbers
+#           └── TestDuplicateFunction
+#               └── test_dup_s
+#
+# Note: This reuses the unittest_folder paths defined earlier in this file.
+project_root_unittest_folder_expected_output = {
+    "name": "unittest_folder",
+    "path": os.fspath(unittest_folder_path),
+    "type_": "folder",
+    "children": [
+        {
+            "name": "test_add.py",
+            "path": os.fspath(test_add_path),
+            "type_": "file",
+            "id_": os.fspath(test_add_path),
+            "children": [
+                {
+                    "name": "TestAddFunction",
+                    "path": os.fspath(test_add_path),
+                    "type_": "class",
+                    "children": [
+                        {
+                            "name": "test_add_negative_numbers",
+                            "path": os.fspath(test_add_path),
+                            "lineno": find_test_line_number(
+                                "test_add_negative_numbers",
+                                os.fspath(test_add_path),
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "test_add.py::TestAddFunction::test_add_negative_numbers",
+                                test_add_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "test_add.py::TestAddFunction::test_add_negative_numbers",
+                                test_add_path,
+                            ),
+                        },
+                        {
+                            "name": "test_add_positive_numbers",
+                            "path": os.fspath(test_add_path),
+                            "lineno": find_test_line_number(
+                                "test_add_positive_numbers",
+                                os.fspath(test_add_path),
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "test_add.py::TestAddFunction::test_add_positive_numbers",
+                                test_add_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "test_add.py::TestAddFunction::test_add_positive_numbers",
+                                test_add_path,
+                            ),
+                        },
+                    ],
+                    "id_": get_absolute_test_id(
+                        "test_add.py::TestAddFunction",
+                        test_add_path,
+                    ),
+                    "lineno": find_class_line_number("TestAddFunction", test_add_path),
+                },
+                {
+                    "name": "TestDuplicateFunction",
+                    "path": os.fspath(test_add_path),
+                    "type_": "class",
+                    "children": [
+                        {
+                            "name": "test_dup_a",
+                            "path": os.fspath(test_add_path),
+                            "lineno": find_test_line_number(
+                                "test_dup_a",
+                                os.fspath(test_add_path),
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "test_add.py::TestDuplicateFunction::test_dup_a",
+                                test_add_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "test_add.py::TestDuplicateFunction::test_dup_a",
+                                test_add_path,
+                            ),
+                        },
+                    ],
+                    "id_": get_absolute_test_id(
+                        "test_add.py::TestDuplicateFunction",
+                        test_add_path,
+                    ),
+                    "lineno": find_class_line_number("TestDuplicateFunction", test_add_path),
+                },
+            ],
+        },
+        {
+            "name": "test_subtract.py",
+            "path": os.fspath(test_subtract_path),
+            "type_": "file",
+            "id_": os.fspath(test_subtract_path),
+            "children": [
+                {
+                    "name": "TestSubtractFunction",
+                    "path": os.fspath(test_subtract_path),
+                    "type_": "class",
+                    "children": [
+                        {
+                            "name": "test_subtract_negative_numbers",
+                            "path": os.fspath(test_subtract_path),
+                            "lineno": find_test_line_number(
+                                "test_subtract_negative_numbers",
+                                os.fspath(test_subtract_path),
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "test_subtract.py::TestSubtractFunction::test_subtract_negative_numbers",
+                                test_subtract_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "test_subtract.py::TestSubtractFunction::test_subtract_negative_numbers",
+                                test_subtract_path,
+                            ),
+                        },
+                        {
+                            "name": "test_subtract_positive_numbers",
+                            "path": os.fspath(test_subtract_path),
+                            "lineno": find_test_line_number(
+                                "test_subtract_positive_numbers",
+                                os.fspath(test_subtract_path),
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "test_subtract.py::TestSubtractFunction::test_subtract_positive_numbers",
+                                test_subtract_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "test_subtract.py::TestSubtractFunction::test_subtract_positive_numbers",
+                                test_subtract_path,
+                            ),
+                        },
+                    ],
+                    "id_": get_absolute_test_id(
+                        "test_subtract.py::TestSubtractFunction",
+                        test_subtract_path,
+                    ),
+                    "lineno": find_class_line_number("TestSubtractFunction", test_subtract_path),
+                },
+                {
+                    "name": "TestDuplicateFunction",
+                    "path": os.fspath(test_subtract_path),
+                    "type_": "class",
+                    "children": [
+                        {
+                            "name": "test_dup_s",
+                            "path": os.fspath(test_subtract_path),
+                            "lineno": find_test_line_number(
+                                "test_dup_s",
+                                os.fspath(test_subtract_path),
+                            ),
+                            "type_": "test",
+                            "id_": get_absolute_test_id(
+                                "test_subtract.py::TestDuplicateFunction::test_dup_s",
+                                test_subtract_path,
+                            ),
+                            "runID": get_absolute_test_id(
+                                "test_subtract.py::TestDuplicateFunction::test_dup_s",
+                                test_subtract_path,
+                            ),
+                        },
+                    ],
+                    "id_": get_absolute_test_id(
+                        "test_subtract.py::TestDuplicateFunction",
+                        test_subtract_path,
+                    ),
+                    "lineno": find_class_line_number("TestDuplicateFunction", test_subtract_path),
+                },
+            ],
+        },
+    ],
+    "id_": os.fspath(unittest_folder_path),
+}
diff --git a/python_files/tests/pytestadapter/helpers.py b/python_files/tests/pytestadapter/helpers.py
index 7a75e6248844..03f1187149df 100644
--- a/python_files/tests/pytestadapter/helpers.py
+++ b/python_files/tests/pytestadapter/helpers.py
@@ -244,7 +244,7 @@ def runner_with_cwd_env(
     """
     process_args: List[str]
     pipe_name: str
-    if "MANAGE_PY_PATH" in env_add:
+    if "MANAGE_PY_PATH" in env_add and "COVERAGE_ENABLED" not in env_add:
         # If we are running Django, generate a unittest-specific pipe name.
         process_args = [sys.executable, *args]
         pipe_name = generate_random_pipe_name("unittest-discovery-test")
@@ -264,17 +264,34 @@ def runner_with_cwd_env(
         pipe_name = generate_random_pipe_name("pytest-discovery-test")
 
     if "COVERAGE_ENABLED" in env_add and "_TEST_VAR_UNITTEST" not in env_add:
-        process_args = [
-            sys.executable,
-            "-m",
-            "pytest",
-            "-p",
-            "vscode_pytest",
-            "--cov=.",
-            "--cov-branch",
-            "-s",
-            *args,
-        ]
+        if "_PYTEST_MANUAL_PLUGIN_LOAD" in env_add:
+            # Test manual plugin loading scenario for issue #25590
+            process_args = [
+                sys.executable,
+                "-m",
+                "pytest",
+                "--disable-plugin-autoload",
+                "-p",
+                "pytest_cov.plugin",
+                "-p",
+                "vscode_pytest",
+                "--cov=.",
+                "--cov-branch",
+                "-s",
+                *args,
+            ]
+        else:
+            process_args = [
+                sys.executable,
+                "-m",
+                "pytest",
+                "-p",
+                "vscode_pytest",
+                "--cov=.",
+                "--cov-branch",
+                "-s",
+                *args,
+            ]
 
     # Generate pipe name, pipe name specific per OS type.
 
@@ -370,6 +387,28 @@ def find_test_line_number(test_name: str, test_file_path) -> str:
     raise ValueError(error_str)
 
 
+def find_class_line_number(class_name: str, test_file_path) -> str:
+    """Function which finds the correct line number for a class definition.
+
+    Args:
+    class_name: The name of the class to find the line number for.
+    test_file_path: The path to the test file where the class is located.
+    """
+    # Look for the class definition line (or function for pytest-describe)
+    with open(test_file_path) as f:  # noqa: PTH123
+        for i, line in enumerate(f):
+            # Match "class ClassName" or "class ClassName(" or "class ClassName:"
+            # Also match "def ClassName(" for pytest-describe blocks
+            if (
+                line.strip().startswith(f"class {class_name}")
+                or line.strip().startswith(f"class {class_name}(")
+                or line.strip().startswith(f"def {class_name}(")
+            ):
+                return str(i + 1)
+    error_str: str = f"Class {class_name!r} not found on any line in {test_file_path}"
+    raise ValueError(error_str)
+
+
 def get_absolute_test_id(test_id: str, test_path: pathlib.Path) -> str:
     """Get the absolute test id by joining the testPath with the test_id."""
     split_id = test_id.split("::")[1:]
diff --git a/python_files/tests/pytestadapter/test_coverage.py b/python_files/tests/pytestadapter/test_coverage.py
index d0f802a23672..f2387527698f 100644
--- a/python_files/tests/pytestadapter/test_coverage.py
+++ b/python_files/tests/pytestadapter/test_coverage.py
@@ -5,7 +5,9 @@
 import pathlib
 import sys
 
+import coverage
 import pytest
+from packaging.version import Version
 
 script_dir = pathlib.Path(__file__).parent.parent
 sys.path.append(os.fspath(script_dir))
@@ -34,9 +36,9 @@ def test_simple_pytest_coverage():
     cov_folder_path = TEST_DATA_PATH / "coverage_gen"
     actual = runner_with_cwd_env(args, cov_folder_path, env_add)
     assert actual
-    coverage = actual[-1]
-    assert coverage
-    results = coverage["result"]
+    cov = actual[-1]
+    assert cov
+    results = cov["result"]
     assert results
     assert len(results) == 3
     focal_function_coverage = results.get(os.fspath(TEST_DATA_PATH / "coverage_gen" / "reverse.py"))
@@ -46,6 +48,12 @@ def test_simple_pytest_coverage():
     assert set(focal_function_coverage.get("lines_covered")) == {4, 5, 7, 9, 10, 11, 12, 13, 14, 17}
     assert len(set(focal_function_coverage.get("lines_missed"))) >= 3
 
+    coverage_version = Version(coverage.__version__)
+    # only include check for branches if the version is >= 7.7.0
+    if coverage_version >= Version("7.7.0"):
+        assert focal_function_coverage.get("executed_branches") == 4
+        assert focal_function_coverage.get("total_branches") == 6
+
 
 coverage_gen_file_path = TEST_DATA_PATH / "coverage_gen" / "coverage.json"
 
@@ -77,9 +85,9 @@ def test_coverage_gen_report(cleanup_coverage_gen_file):  # noqa: ARG001
     print("cov_folder_path", cov_folder_path)
     actual = runner_with_cwd_env(args, cov_folder_path, env_add)
     assert actual
-    coverage = actual[-1]
-    assert coverage
-    results = coverage["result"]
+    cov = actual[-1]
+    assert cov
+    results = cov["result"]
     assert results
     assert len(results) == 3
     focal_function_coverage = results.get(os.fspath(TEST_DATA_PATH / "coverage_gen" / "reverse.py"))
@@ -88,6 +96,11 @@ def test_coverage_gen_report(cleanup_coverage_gen_file):  # noqa: ARG001
     assert focal_function_coverage.get("lines_missed") is not None
     assert set(focal_function_coverage.get("lines_covered")) == {4, 5, 7, 9, 10, 11, 12, 13, 14, 17}
     assert set(focal_function_coverage.get("lines_missed")) == {18, 19, 6}
+    coverage_version = Version(coverage.__version__)
+    # only include check for branches if the version is >= 7.7.0
+    if coverage_version >= Version("7.7.0"):
+        assert focal_function_coverage.get("executed_branches") == 4
+        assert focal_function_coverage.get("total_branches") == 6
     # assert that the coverage file was created at the right path
     assert os.path.exists(coverage_gen_file_path)  # noqa: PTH110
 
@@ -123,9 +136,29 @@ def test_coverage_w_omit_config():
     actual = runner_with_cwd_env([], cov_folder_path, env_add)
     assert actual
     print("actual", json.dumps(actual, indent=2))
-    coverage = actual[-1]
-    assert coverage
-    results = coverage["result"]
+    cov = actual[-1]
+    assert cov
+    results = cov["result"]
     assert results
     # assert one file is reported and one file (as specified in pyproject.toml) is omitted
     assert len(results) == 1
+
+
+def test_pytest_cov_manual_plugin_loading():
+    """
+    Test that pytest-cov is detected when loaded manually via -p pytest_cov.plugin.
+
+    This test verifies the fix for issue #25590, where pytest-cov detection failed
+    when using --disable-plugin-autoload with -p pytest_cov.plugin. The plugin is
+    registered under its module name (pytest_cov.plugin) instead of entry point name
+    (pytest_cov) in this scenario.
+    """
+    args = ["--collect-only"]
+    env_add = {"COVERAGE_ENABLED": "True", "_PYTEST_MANUAL_PLUGIN_LOAD": "True"}
+    cov_folder_path = TEST_DATA_PATH / "coverage_gen"
+
+    # Should NOT raise VSCodePytestError about pytest-cov not being installed
+    actual = runner_with_cwd_env(args, cov_folder_path, env_add)
+    assert actual is not None
+    # Verify discovery succeeded (status != "error")
+    assert actual[0].get("status") != "error"
diff --git a/python_files/tests/pytestadapter/test_discovery.py b/python_files/tests/pytestadapter/test_discovery.py
index 4f9fe3eb19ac..cf777399fed9 100644
--- a/python_files/tests/pytestadapter/test_discovery.py
+++ b/python_files/tests/pytestadapter/test_discovery.py
@@ -337,15 +337,37 @@ def test_config_sub_folder():
             assert tests.get("name") == "config_sub_folder"
 
 
-def test_ruff_plugin():
-    """Here the session node will be a subfolder of the workspace root and the test are in another subfolder.
+@pytest.mark.parametrize(
+    ("file", "expected_const", "extra_arg"),
+    [
+        (
+            "folder_with_script",
+            expected_discovery_test_output.ruff_test_expected_output,
+            "--ruff",
+        ),
+        (
+            "2496-black-formatter",
+            expected_discovery_test_output.black_formatter_expected_output,
+            "--black",
+        ),
+    ],
+)
+def test_plugin_collect(file, expected_const, extra_arg):
+    """Test pytest discovery on a folder with a plugin argument (e.g., --ruff, --black).
 
-    This tests checks to see if test node path are under the session node and if so the
-    session node is correctly updated to the common path.
+    Uses variables from expected_discovery_test_output.py to store the expected
+    dictionary return. Only handles discovery and therefore already contains the arg
+    --collect-only. All test discovery will succeed, be in the correct cwd, and match
+    expected test output.
+
+    Keyword arguments:
+    file -- a string with the file or folder to run pytest discovery on.
+    expected_const -- the expected output from running pytest discovery on the file.
+    extra_arg -- the extra plugin argument to pass (e.g., --ruff, --black)
     """
-    file_path = helpers.TEST_DATA_PATH / "folder_with_script"
+    file_path = helpers.TEST_DATA_PATH / file
     actual = helpers.runner(
-        [os.fspath(file_path), "--collect-only", "--ruff"],
+        [os.fspath(file_path), "--collect-only", extra_arg],
     )
 
     assert actual
@@ -359,8 +381,102 @@ def test_ruff_plugin():
         assert actual_item.get("cwd") == os.fspath(helpers.TEST_DATA_PATH)
         assert is_same_tree(
             actual_item.get("tests"),
-            expected_discovery_test_output.ruff_test_expected_output,
+            expected_const,
             ["id_", "lineno", "name", "runID"],
         ), (
-            f"Tests tree does not match expected value. \n Expected: {json.dumps(expected_discovery_test_output.ruff_test_expected_output, indent=4)}. \n Actual: {json.dumps(actual_item.get('tests'), indent=4)}"
+            f"Tests tree does not match expected value. \n Expected: {json.dumps(expected_const, indent=4)}. \n Actual: {json.dumps(actual_item.get('tests'), indent=4)}"
+        )
+
+
+def test_project_root_path_env_var():
+    """Test pytest discovery with PROJECT_ROOT_PATH environment variable set.
+
+    This simulates project-based testing where the test tree root should be
+    the project root (PROJECT_ROOT_PATH) rather than the workspace cwd.
+
+    When PROJECT_ROOT_PATH is set:
+    - The test tree root (name, path, id_) should match PROJECT_ROOT_PATH
+    - The cwd in the response should match PROJECT_ROOT_PATH
+    - Test files should be direct children of the root (not nested under a subfolder)
+    """
+    # Use unittest_folder as our "project" subdirectory
+    project_path = helpers.TEST_DATA_PATH / "unittest_folder"
+
+    actual = helpers.runner_with_cwd_env(
+        [os.fspath(project_path), "--collect-only"],
+        helpers.TEST_DATA_PATH,  # cwd is parent of project
+        {"PROJECT_ROOT_PATH": os.fspath(project_path)},  # Set project root
+    )
+
+    assert actual
+    actual_list: List[Dict[str, Any]] = actual
+    if actual_list is not None:
+        actual_item = actual_list.pop(0)
+
+        assert all(item in actual_item for item in ("status", "cwd", "error"))
+        assert actual_item.get("status") == "success", (
+            f"Status is not 'success', error is: {actual_item.get('error')}"
         )
+        # cwd in response should be PROJECT_ROOT_PATH
+        assert actual_item.get("cwd") == os.fspath(project_path), (
+            f"Expected cwd '{os.fspath(project_path)}', got '{actual_item.get('cwd')}'"
+        )
+        assert is_same_tree(
+            actual_item.get("tests"),
+            expected_discovery_test_output.project_root_unittest_folder_expected_output,
+            ["id_", "lineno", "name", "runID"],
+        ), (
+            f"Tests tree does not match expected value. \n Expected: {json.dumps(expected_discovery_test_output.project_root_unittest_folder_expected_output, indent=4)}. \n Actual: {json.dumps(actual_item.get('tests'), indent=4)}"
+        )
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="Symlinks require elevated privileges on Windows",
+)
+def test_symlink_with_project_root_path():
+    """Test pytest discovery with both symlink and PROJECT_ROOT_PATH set.
+
+    This tests the combination of:
+    1. A symlinked test directory (--rootdir points to symlink)
+    2. PROJECT_ROOT_PATH set to the symlink path
+
+    This simulates project-based testing where the project root is a symlink,
+    ensuring test IDs and paths are correctly resolved through the symlink.
+    """
+    with helpers.create_symlink(helpers.TEST_DATA_PATH, "root", "symlink_folder") as (
+        source,
+        destination,
+    ):
+        assert destination.is_symlink()
+
+        # Run pytest with:
+        # - cwd being the resolved symlink path (simulating subprocess from node)
+        # - PROJECT_ROOT_PATH set to the symlink destination
+        actual = helpers.runner_with_cwd_env(
+            ["--collect-only", f"--rootdir={os.fspath(destination)}"],
+            source,  # cwd is the resolved (non-symlink) path
+            {"PROJECT_ROOT_PATH": os.fspath(destination)},  # Project root is the symlink
+        )
+
+        expected = expected_discovery_test_output.symlink_expected_discovery_output
+        assert actual
+        actual_list: List[Dict[str, Any]] = actual
+        if actual_list is not None:
+            actual_item = actual_list.pop(0)
+            try:
+                assert all(item in actual_item for item in ("status", "cwd", "error")), (
+                    "Required keys are missing"
+                )
+                assert actual_item.get("status") == "success", (
+                    f"Status is not 'success', error is: {actual_item.get('error')}"
+                )
+                # cwd should be the PROJECT_ROOT_PATH (the symlink destination)
+                assert actual_item.get("cwd") == os.fspath(destination), (
+                    f"CWD does not match symlink path: expected {os.fspath(destination)}, got {actual_item.get('cwd')}"
+                )
+                assert actual_item.get("tests") == expected, "Tests do not match expected value"
+            except AssertionError as e:
+                # Print the actual_item in JSON format if an assertion fails
+                print(json.dumps(actual_item, indent=4))
+                pytest.fail(str(e))
diff --git a/python_files/tests/pytestadapter/test_utils.py b/python_files/tests/pytestadapter/test_utils.py
index ef0ed2daf4e9..70201db7d097 100644
--- a/python_files/tests/pytestadapter/test_utils.py
+++ b/python_files/tests/pytestadapter/test_utils.py
@@ -12,7 +12,7 @@
 
 script_dir = pathlib.Path(__file__).parent.parent.parent
 sys.path.append(os.fspath(script_dir))
-from vscode_pytest import has_symlink_parent  # noqa: E402
+from vscode_pytest import cached_fsdecode, has_symlink_parent  # noqa: E402
 
 
 def test_has_symlink_parent_with_symlink():
@@ -33,3 +33,25 @@ def test_has_symlink_parent_without_symlink():
     folder_path = TEST_DATA_PATH / "unittest_folder" / "test_add.py"
     # Check that has_symlink_parent correctly identifies that there are no symbolic links
     assert not has_symlink_parent(folder_path)
+
+
+def test_cached_fsdecode():
+    """Test that cached_fsdecode correctly caches path-to-string conversions."""
+    # Create a test path
+    test_path = TEST_DATA_PATH / "simple_pytest.py"
+
+    # First call should compute and cache
+    result1 = cached_fsdecode(test_path)
+    assert result1 == os.fspath(test_path)
+    assert isinstance(result1, str)
+
+    # Second call should return cached value (same object)
+    result2 = cached_fsdecode(test_path)
+    assert result2 == result1
+    assert result2 is result1  # Should be the same object from cache
+
+    # Different path should be cached independently
+    test_path2 = TEST_DATA_PATH / "parametrize_tests.py"
+    result3 = cached_fsdecode(test_path2)
+    assert result3 == os.fspath(test_path2)
+    assert result3 != result1
diff --git a/python_files/tests/test_create_venv.py b/python_files/tests/test_create_venv.py
index 72fabdaaecac..6308934d71a0 100644
--- a/python_files/tests/test_create_venv.py
+++ b/python_files/tests/test_create_venv.py
@@ -122,7 +122,7 @@ def create_gitignore(_p):
 def test_install_packages(install_type):
     importlib.reload(create_venv)
     create_venv.is_installed = lambda _x: True
-    create_venv.file_exists = lambda x: install_type in x
+    create_venv.file_exists = lambda x: install_type in str(x)
 
     pip_upgraded = False
     installing = None
diff --git a/python_files/tests/test_python_server.py b/python_files/tests/test_python_server.py
new file mode 100644
index 000000000000..ca542b8ea292
--- /dev/null
+++ b/python_files/tests/test_python_server.py
@@ -0,0 +1,162 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+"""Tests for python_server.py, specifically EOF handling to prevent infinite loops."""
+
+import io
+from unittest import mock
+
+import pytest
+
+
+class TestGetHeaders:
+    """Tests for the get_headers function."""
+
+    def test_get_headers_normal(self):
+        """Test get_headers with valid headers."""
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin with valid headers
+        mock_input = b"Content-Length: 100\r\nContent-Type: application/json\r\n\r\n"
+        mock_stdin = io.BytesIO(mock_input)
+
+        # Act
+        with mock.patch.object(python_server, "STDIN", mock.Mock(buffer=mock_stdin)):
+            headers = python_server.get_headers()
+
+        # Assert
+        assert headers == {"Content-Length": "100", "Content-Type": "application/json"}
+
+    def test_get_headers_eof_raises_error(self):
+        """Test that get_headers raises EOFError when stdin is closed (EOF)."""
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin that returns empty bytes (EOF)
+        mock_stdin = io.BytesIO(b"")
+
+        # Act & Assert
+        with mock.patch.object(python_server, "STDIN", mock.Mock(buffer=mock_stdin)), pytest.raises(
+            EOFError, match="EOF reached while reading headers"
+        ):
+            python_server.get_headers()
+
+    def test_get_headers_eof_mid_headers_raises_error(self):
+        """Test that get_headers raises EOFError when EOF occurs mid-headers."""
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin with partial headers then EOF
+        mock_input = b"Content-Length: 100\r\n"  # No terminating empty line
+        mock_stdin = io.BytesIO(mock_input)
+
+        # Act & Assert
+        with mock.patch.object(python_server, "STDIN", mock.Mock(buffer=mock_stdin)), pytest.raises(
+            EOFError, match="EOF reached while reading headers"
+        ):
+            python_server.get_headers()
+
+    def test_get_headers_empty_line_terminates(self):
+        """Test that an empty line (not EOF) properly terminates header reading."""
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin with headers followed by empty line
+        mock_input = b"Content-Length: 50\r\n\r\nsome body content"
+        mock_stdin = io.BytesIO(mock_input)
+
+        # Act
+        with mock.patch.object(python_server, "STDIN", mock.Mock(buffer=mock_stdin)):
+            headers = python_server.get_headers()
+
+        # Assert
+        assert headers == {"Content-Length": "50"}
+
+
+class TestEOFHandling:
+    """Tests for EOF handling in various functions that use get_headers."""
+
+    def test_custom_input_exits_on_eof(self):
+        """Test that custom_input exits gracefully on EOF."""
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin that returns empty bytes (EOF)
+        mock_stdin = io.BytesIO(b"")
+        mock_stdout = io.BytesIO()
+
+        # Act & Assert
+        with mock.patch.object(
+            python_server, "STDIN", mock.Mock(buffer=mock_stdin)
+        ), mock.patch.object(python_server, "STDOUT", mock.Mock(buffer=mock_stdout)), pytest.raises(
+            SystemExit
+        ) as exc_info:
+            python_server.custom_input("prompt> ")
+
+        # Should exit with code 0 (graceful exit)
+        assert exc_info.value.code == 0
+
+    def test_handle_response_exits_on_eof(self):
+        """Test that handle_response exits gracefully on EOF."""
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin that returns empty bytes (EOF)
+        mock_stdin = io.BytesIO(b"")
+
+        # Act & Assert
+        with mock.patch.object(python_server, "STDIN", mock.Mock(buffer=mock_stdin)), pytest.raises(
+            SystemExit
+        ) as exc_info:
+            python_server.handle_response("test-request-id")
+
+        # Should exit with code 0 (graceful exit)
+        assert exc_info.value.code == 0
+
+
+class TestMainLoopEOFHandling:
+    """Tests that simulate the main loop EOF scenario."""
+
+    def test_main_loop_exits_on_eof(self):
+        """Test that the main loop pattern exits gracefully on EOF.
+
+        This test verifies the fix for GitHub issue #25620 where the server
+        would spin at 100% CPU instead of exiting when VS Code closes.
+        """
+        # Arrange: Import the module
+        import python_server
+
+        # Create a mock stdin that returns empty bytes (EOF)
+        mock_stdin = io.BytesIO(b"")
+
+        # Simulate what happens in the main loop
+        with mock.patch.object(python_server, "STDIN", mock.Mock(buffer=mock_stdin)):
+            try:
+                python_server.get_headers()
+                # If we get here without raising EOFError, the fix isn't working
+                pytest.fail("Expected EOFError to be raised on EOF")
+            except EOFError:
+                # This is the expected behavior - the fix is working
+                pass
+
+    def test_readline_eof_vs_empty_line(self):
+        """Test that we correctly distinguish between EOF and empty line.
+
+        EOF: readline() returns b'' (empty bytes)
+        Empty line: readline() returns b'\\r\\n' or b'\\n' (newline bytes)
+        """
+        # Test EOF case
+        eof_stream = io.BytesIO(b"")
+        result = eof_stream.readline()
+        assert result == b"", "EOF should return empty bytes"
+
+        # Test empty line case
+        empty_line_stream = io.BytesIO(b"\r\n")
+        result = empty_line_stream.readline()
+        assert result == b"\r\n", "Empty line should return newline bytes"
+
+        # Test empty line with just newline
+        empty_line_stream2 = io.BytesIO(b"\n")
+        result = empty_line_stream2.readline()
+        assert result == b"\n", "Empty line should return newline bytes"
diff --git a/python_files/tests/test_shell_integration.py b/python_files/tests/test_shell_integration.py
index 376cb466bb50..7503a725b6d1 100644
--- a/python_files/tests/test_shell_integration.py
+++ b/python_files/tests/test_shell_integration.py
@@ -17,7 +17,7 @@ def test_decoration_success():
     if sys.platform != "win32" and (not is_wsl):
         assert (
             result
-            == "\x1b]633;E;None\x07\x1b]633;D;0\x07\x1b]633;A\x07>>> \x1b]633;B\x07\x1b]633;C\x07"
+            == "\x01\x1b]633;C\x07\x1b]633;E;None\x07\x1b]633;D;0\x07\x1b]633;A\x07\x02>>> \x01\x1b]633;B\x07\x02"
         )
     else:
         pass
@@ -32,7 +32,7 @@ def test_decoration_failure():
     if sys.platform != "win32" and (not is_wsl):
         assert (
             result
-            == "\x1b]633;E;None\x07\x1b]633;D;1\x07\x1b]633;A\x07>>> \x1b]633;B\x07\x1b]633;C\x07"
+            == "\x01\x1b]633;C\x07\x1b]633;E;None\x07\x1b]633;D;1\x07\x1b]633;A\x07\x02>>> \x01\x1b]633;B\x07\x02"
         )
     else:
         pass
diff --git a/python_files/tests/unittestadapter/.data/doctest_patched_module.py b/python_files/tests/unittestadapter/.data/doctest_patched_module.py
new file mode 100644
index 000000000000..636c5320b6d6
--- /dev/null
+++ b/python_files/tests/unittestadapter/.data/doctest_patched_module.py
@@ -0,0 +1,17 @@
+"""
+Patched doctest module.
+This module's doctests will be patched to have proper IDs.
+
+>>> 2 + 2
+4
+"""
+
+
+def example_function():
+    """
+    Example function with doctest.
+
+    >>> example_function()
+    'works'
+    """
+    return "works"
diff --git a/python_files/tests/unittestadapter/.data/doctest_standard.py b/python_files/tests/unittestadapter/.data/doctest_standard.py
new file mode 100644
index 000000000000..52a10aa46a7f
--- /dev/null
+++ b/python_files/tests/unittestadapter/.data/doctest_standard.py
@@ -0,0 +1,7 @@
+"""
+Standard doctest module that should be blocked.
+This has a simple doctest with short ID.
+
+>>> 2 + 2
+4
+"""
diff --git a/python_files/tests/unittestadapter/.data/simple_django/old_manage.py b/python_files/tests/unittestadapter/.data/simple_django/old_manage.py
new file mode 100755
index 000000000000..844b98b4edba
--- /dev/null
+++ b/python_files/tests/unittestadapter/.data/simple_django/old_manage.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+import os
+import sys
+if __name__ == "__main__":
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysite.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError:
+        # The above import may fail for some other reason. Ensure that the
+        # issue is really that Django is missing to avoid masking other
+        # exceptions on Python 2.
+        try:
+            import django
+        except ImportError:
+            raise ImportError(
+                "Couldn't import Django. Are you sure it's installed and "
+                "available on your PYTHONPATH environment variable? Did you "
+                "forget to activate a virtual environment?"
+            )
+        raise
+    execute_from_command_line(sys.argv)
diff --git a/python_files/tests/unittestadapter/.data/test_doctest_patched.py b/python_files/tests/unittestadapter/.data/test_doctest_patched.py
new file mode 100644
index 000000000000..3a719c7139ca
--- /dev/null
+++ b/python_files/tests/unittestadapter/.data/test_doctest_patched.py
@@ -0,0 +1,50 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Test file with patched doctest integration that should work."""
+
+import unittest
+import doctest
+import sys
+import doctest_patched_module
+
+
+# Patch DocTestCase to modify test IDs to be compatible with the extension
+original_init = doctest.DocTestCase.__init__
+
+
+def patched_init(self, test, optionflags=0, setUp=None, tearDown=None, checker=None):
+    """Patch to modify doctest names to have proper hierarchy."""
+    if hasattr(test, 'name'):
+        # Get module name
+        module_hierarchy = test.name.split('.')
+        module_name = module_hierarchy[0] if module_hierarchy else 'unknown'
+
+        # Reconstruct with proper formatting to have enough components
+        # Format: module.file.class.function
+        if test.filename.endswith('.py'):
+            file_base = test.filename.split('/')[-1].replace('.py', '')
+            test_name = test.name.split('.')[-1] if '.' in test.name else test.name
+            # Create a properly formatted ID with enough components
+            test.name = f"{module_name}.{file_base}._DocTests.{test_name}"
+
+    # Call original init
+    original_init(self, test, optionflags, setUp, tearDown, checker)
+
+
+# Apply the patch
+doctest.DocTestCase.__init__ = patched_init
+
+
+def load_tests(loader, tests, ignore):
+    """
+    Standard hook for unittest to load tests.
+    This uses patched doctest to create compatible test IDs.
+    """
+    tests.addTests(doctest.DocTestSuite(doctest_patched_module))
+    return tests
+
+
+# Clean up the patch after loading
+def tearDownModule():
+    """Restore original DocTestCase.__init__"""
+    doctest.DocTestCase.__init__ = original_init
diff --git a/python_files/tests/unittestadapter/.data/test_doctest_standard.py b/python_files/tests/unittestadapter/.data/test_doctest_standard.py
new file mode 100644
index 000000000000..f5dba1209b98
--- /dev/null
+++ b/python_files/tests/unittestadapter/.data/test_doctest_standard.py
@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Test file with standard doctest integration that should be blocked."""
+
+import unittest
+import doctest
+import doctest_standard
+
+
+def load_tests(loader, tests, ignore):
+    """
+    Standard hook for unittest to load tests.
+    This uses standard doctest without any patching.
+    """
+    tests.addTests(doctest.DocTestSuite(doctest_standard))
+    return tests
diff --git a/python_files/tests/unittestadapter/.data/test_scenarios/tests/__init__.py b/python_files/tests/unittestadapter/.data/test_scenarios/tests/__init__.py
index 6b8fbbc579ab..5b7f7a925cc0 100644
--- a/python_files/tests/unittestadapter/.data/test_scenarios/tests/__init__.py
+++ b/python_files/tests/unittestadapter/.data/test_scenarios/tests/__init__.py
@@ -1,15 +1,2 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
-
-import os
-
-import testresources
-from testscenarios import generate_scenarios
-
-def load_tests(loader, tests, pattern):
-    this_dir = os.path.dirname(__file__)
-    mytests = loader.discover(start_dir=this_dir, pattern=pattern)
-    result = testresources.OptimisingTestSuite()
-    result.addTests(generate_scenarios(mytests))
-    result.addTests(generate_scenarios(tests))
-    return result
diff --git a/python_files/tests/unittestadapter/.data/test_scenarios/tests/test_scene.py b/python_files/tests/unittestadapter/.data/test_scenarios/tests/test_scene.py
index 1f66cbde4ef7..35c1c7002319 100644
--- a/python_files/tests/unittestadapter/.data/test_scenarios/tests/test_scene.py
+++ b/python_files/tests/unittestadapter/.data/test_scenarios/tests/test_scene.py
@@ -1,13 +1,27 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
-from testscenarios import TestWithScenarios
+import unittest
+
+from testscenarios import TestWithScenarios, generate_scenarios
+
+
+def load_tests(loader, standard_tests, pattern):  # noqa: ARG001
+    # Pre-expand ``TestWithScenarios`` scenarios at load time so individual
+    # scenario-multiplied test IDs (e.g. ``test_operations(add)``) can be
+    # resolved by ``unittest.TestLoader.loadTestsFromName``. Without this,
+    # ``TestWithScenarios`` only multiplies scenarios at ``run()`` time and
+    # loading a specific scenario by name raises ``AttributeError``.
+    result = unittest.TestSuite()
+    result.addTests(generate_scenarios(standard_tests))
+    return result
+
 
 class TestMathOperations(TestWithScenarios):
     scenarios = [
         ('add', {'test_id': 'test_add', 'a': 5, 'b': 3, 'expected': 8}),
         ('subtract', {'test_id': 'test_subtract', 'a': 5, 'b': 3, 'expected': 2}),
-        ('multiply', {'test_id': 'test_multiply', 'a': 5, 'b': 3, 'expected': 15})
+        ('multiply', {'test_id': 'test_multiply', 'a': 5, 'b': 3, 'expected': 15}),
     ]
     a: int = 0
     b: int = 0
diff --git a/python_files/tests/unittestadapter/expected_discovery_test_output.py b/python_files/tests/unittestadapter/expected_discovery_test_output.py
index 9de0eff8238c..0901f21bfbc2 100644
--- a/python_files/tests/unittestadapter/expected_discovery_test_output.py
+++ b/python_files/tests/unittestadapter/expected_discovery_test_output.py
@@ -9,6 +9,25 @@
 TEST_DATA_PATH = pathlib.Path(__file__).parent / ".data"
 
 
+def find_class_line_number(class_name: str, test_file_path) -> str:
+    """Function which finds the correct line number for a class definition.
+
+    Args:
+    class_name: The name of the class to find the line number for.
+    test_file_path: The path to the test file where the class is located.
+    """
+    # Look for the class definition line
+    with pathlib.Path(test_file_path).open() as f:
+        for i, line in enumerate(f):
+            # Match "class ClassName" or "class ClassName(" or "class ClassName:"
+            if line.strip().startswith(f"class {class_name}") or line.strip().startswith(
+                f"class {class_name}("
+            ):
+                return str(i + 1)
+    error_str: str = f"Class {class_name!r} not found on any line in {test_file_path}"
+    raise ValueError(error_str)
+
+
 skip_unittest_folder_discovery_output = {
     "path": os.fspath(TEST_DATA_PATH / "unittest_skip"),
     "name": "unittest_skip",
@@ -49,6 +68,10 @@
                     ],
                     "id_": os.fspath(TEST_DATA_PATH / "unittest_skip" / "unittest_skip_function.py")
                     + "\\SimpleTest",
+                    "lineno": find_class_line_number(
+                        "SimpleTest",
+                        TEST_DATA_PATH / "unittest_skip" / "unittest_skip_function.py",
+                    ),
                 }
             ],
             "id_": os.fspath(TEST_DATA_PATH / "unittest_skip" / "unittest_skip_function.py"),
@@ -114,6 +137,16 @@
                                         },
                                     ],
                                     "id_": complex_tree_file_path + "\\" + "TreeOne",
+                                    "lineno": find_class_line_number(
+                                        "TreeOne",
+                                        pathlib.PurePath(
+                                            TEST_DATA_PATH,
+                                            "utils_complex_tree",
+                                            "test_outer_folder",
+                                            "test_inner_folder",
+                                            "test_utils_complex_tree.py",
+                                        ),
+                                    ),
                                 }
                             ],
                             "id_": complex_tree_file_path,
diff --git a/python_files/tests/unittestadapter/test_coverage.py b/python_files/tests/unittestadapter/test_coverage.py
index 594aa764370e..76fdfec43376 100644
--- a/python_files/tests/unittestadapter/test_coverage.py
+++ b/python_files/tests/unittestadapter/test_coverage.py
@@ -8,6 +8,10 @@
 import pathlib
 import sys
 
+import coverage
+import pytest
+from packaging.version import Version
+
 sys.path.append(os.fspath(pathlib.Path(__file__).parent))
 
 python_files_path = pathlib.Path(__file__).parent.parent.parent
@@ -38,9 +42,9 @@ def test_basic_coverage():
     )
 
     assert actual
-    coverage = actual[-1]
-    assert coverage
-    results = coverage["result"]
+    cov = actual[-1]
+    assert cov
+    results = cov["result"]
     assert results
     assert len(results) == 3
     focal_function_coverage = results.get(os.fspath(TEST_DATA_PATH / "coverage_ex" / "reverse.py"))
@@ -49,3 +53,54 @@ def test_basic_coverage():
     assert focal_function_coverage.get("lines_missed") is not None
     assert set(focal_function_coverage.get("lines_covered")) == {4, 5, 7, 9, 10, 11, 12, 13, 14}
     assert set(focal_function_coverage.get("lines_missed")) == {6}
+    coverage_version = Version(coverage.__version__)
+    # only include check for branches if the version is >= 7.7.0
+    if coverage_version >= Version("7.7.0"):
+        assert focal_function_coverage.get("executed_branches") == 3
+        assert focal_function_coverage.get("total_branches") == 4
+
+
+@pytest.mark.parametrize("manage_py_file", ["manage.py", "old_manage.py"])
+@pytest.mark.timeout(30)
+def test_basic_django_coverage(manage_py_file):
+    """This test validates that the coverage is correctly calculated for a Django project."""
+    data_path: pathlib.Path = TEST_DATA_PATH / "simple_django"
+    manage_py_path: str = os.fsdecode(data_path / manage_py_file)
+    execution_script: pathlib.Path = python_files_path / "unittestadapter" / "execution.py"
+
+    test_ids = [
+        "polls.tests.QuestionModelTests.test_was_published_recently_with_future_question",
+        "polls.tests.QuestionModelTests.test_was_published_recently_with_future_question_2",
+        "polls.tests.QuestionModelTests.test_question_creation_and_retrieval",
+    ]
+
+    script_str = os.fsdecode(execution_script)
+    actual = helpers.runner_with_cwd_env(
+        [script_str, "--udiscovery", "-p", "*test*.py", *test_ids],
+        data_path,
+        {
+            "MANAGE_PY_PATH": manage_py_path,
+            "_TEST_VAR_UNITTEST": "True",
+            "COVERAGE_ENABLED": os.fspath(data_path),
+        },
+    )
+
+    assert actual
+    cov = actual[-1]
+    assert cov
+    results = cov["result"]
+    assert results
+    assert len(results) == 16
+    polls_views_coverage = results.get(str(data_path / "polls" / "views.py"))
+    assert polls_views_coverage
+    assert polls_views_coverage.get("lines_covered") is not None
+    assert polls_views_coverage.get("lines_missed") is not None
+    assert set(polls_views_coverage.get("lines_covered")) == {3, 4, 6}
+    assert set(polls_views_coverage.get("lines_missed")) == {7}
+
+    model_cov = results.get(str(data_path / "polls" / "models.py"))
+    coverage_version = Version(coverage.__version__)
+    # only include check for branches if the version is >= 7.7.0
+    if coverage_version >= Version("7.7.0"):
+        assert model_cov.get("executed_branches") == 1
+        assert model_cov.get("total_branches") == 2
diff --git a/python_files/tests/unittestadapter/test_discovery.py b/python_files/tests/unittestadapter/test_discovery.py
index a10b5c406680..ab028ef176c3 100644
--- a/python_files/tests/unittestadapter/test_discovery.py
+++ b/python_files/tests/unittestadapter/test_discovery.py
@@ -325,3 +325,123 @@ def test_simple_django_collect():
         assert (
             len(actual_item["tests"]["children"][0]["children"][0]["children"][0]["children"]) == 3
         )
+
+
+def test_project_root_path_with_cwd_override() -> None:
+    """Test unittest discovery with project_root_path parameter.
+
+    This simulates project-based testing where the cwd in the payload should be
+    the project root (project_root_path) rather than the start_dir.
+
+    When project_root_path is provided:
+    - The cwd in the response should match project_root_path
+    - The test tree root should still be built correctly based on top_level_dir
+    """
+    # Use unittest_skip folder as our "project" directory
+    project_path = TEST_DATA_PATH / "unittest_skip"
+    start_dir = os.fsdecode(project_path)
+    pattern = "unittest_*"
+
+    # Call discover_tests with project_root_path to simulate PROJECT_ROOT_PATH
+    actual = discover_tests(start_dir, pattern, None, project_root_path=start_dir)
+
+    assert actual["status"] == "success"
+    # cwd in response should match the project_root_path (project root)
+    assert actual["cwd"] == os.fsdecode(project_path), (
+        f"Expected cwd '{os.fsdecode(project_path)}', got '{actual['cwd']}'"
+    )
+    assert "tests" in actual
+    # Verify the test tree structure matches expected output
+    assert is_same_tree(
+        actual.get("tests"),
+        expected_discovery_test_output.skip_unittest_folder_discovery_output,
+        ["id_", "lineno", "name"],
+    )
+    assert "error" not in actual
+
+
+def test_project_root_path_with_different_cwd_and_start_dir() -> None:
+    """Test unittest discovery where project_root_path differs from start_dir.
+
+    This simulates the scenario where:
+    - start_dir points to a subfolder where tests are located
+    - project_root_path (PROJECT_ROOT_PATH) points to the project root
+
+    The cwd in the response should be the project root, while discovery
+    still runs from the start_dir.
+    """
+    # Use utils_complex_tree as our test case - discovery from a subfolder
+    project_path = TEST_DATA_PATH / "utils_complex_tree"
+    start_dir = os.fsdecode(
+        pathlib.PurePath(
+            TEST_DATA_PATH,
+            "utils_complex_tree",
+            "test_outer_folder",
+            "test_inner_folder",
+        )
+    )
+    pattern = "test_*.py"
+    top_level_dir = os.fsdecode(project_path)
+
+    # Call discover_tests with project_root_path set to project root
+    actual = discover_tests(start_dir, pattern, top_level_dir, project_root_path=top_level_dir)
+
+    assert actual["status"] == "success"
+    # cwd should be the project root (project_root_path), not the start_dir
+    assert actual["cwd"] == os.fsdecode(project_path), (
+        f"Expected cwd '{os.fsdecode(project_path)}', got '{actual['cwd']}'"
+    )
+    assert "error" not in actual
+    # Test tree should still be structured correctly with top_level_dir as root
+    assert is_same_tree(
+        actual.get("tests"),
+        expected_discovery_test_output.complex_tree_expected_output,
+        ["id_", "lineno", "name"],
+    )
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="Symlinks require elevated privileges on Windows",
+)
+def test_symlink_with_project_root_path() -> None:
+    """Test unittest discovery with both symlink and PROJECT_ROOT_PATH set.
+
+    This tests the combination of:
+    1. A symlinked test directory
+    2. project_root_path (PROJECT_ROOT_PATH) set to the symlink path
+
+    This simulates project-based testing where the project root is a symlink,
+    ensuring test IDs and paths are correctly resolved through the symlink.
+    """
+    with helpers.create_symlink(TEST_DATA_PATH, "unittest_skip", "symlink_unittest") as (
+        _source,
+        destination,
+    ):
+        assert destination.is_symlink()
+
+        # Run discovery with:
+        # - start_dir pointing to the symlink destination
+        # - project_root_path set to the symlink destination (simulating PROJECT_ROOT_PATH)
+        start_dir = os.fsdecode(destination)
+        pattern = "unittest_*"
+
+        actual = discover_tests(start_dir, pattern, None, project_root_path=start_dir)
+
+        assert actual["status"] == "success", (
+            f"Status is not 'success', error is: {actual.get('error')}"
+        )
+        # cwd should be the symlink path (project_root_path)
+        assert actual["cwd"] == os.fsdecode(destination), (
+            f"CWD does not match symlink path: expected {os.fsdecode(destination)}, got {actual['cwd']}"
+        )
+        assert "tests" in actual
+        assert actual["tests"] is not None
+        # The test tree root should be named after the symlink directory
+        assert actual["tests"]["name"] == "symlink_unittest", (
+            f"Expected root name 'symlink_unittest', got '{actual['tests']['name']}'"
+        )
+        # The test tree root path should use the symlink path
+        assert actual["tests"]["path"] == os.fsdecode(destination), (
+            f"Expected root path to be symlink, got '{actual['tests']['path']}'"
+        )
diff --git a/python_files/tests/unittestadapter/test_execution.py b/python_files/tests/unittestadapter/test_execution.py
index f369c6d770b0..cab03f0b5dc4 100644
--- a/python_files/tests/unittestadapter/test_execution.py
+++ b/python_files/tests/unittestadapter/test_execution.py
@@ -341,3 +341,134 @@ def test_basic_run_django():
             assert id_result["outcome"] == "failure"
         else:
             assert id_result["outcome"] == "success"
+
+
+def test_project_root_path_with_cwd_override(mock_send_run_data) -> None:  # noqa: ARG001
+    """Test unittest execution with project_root_path parameter.
+
+    This simulates project-based testing where the cwd in the payload should be
+    the project root (project_root_path) rather than the start_dir.
+
+    When project_root_path is provided:
+    - The cwd in the response should match project_root_path
+    - Test execution should still work correctly with start_dir
+    """
+    # Use unittest_folder as our "project" directory
+    project_path = TEST_DATA_PATH / "unittest_folder"
+    start_dir = os.fsdecode(project_path)
+    pattern = "test_add*"
+    test_ids = [
+        "test_add.TestAddFunction.test_add_positive_numbers",
+    ]
+
+    os.environ["TEST_RUN_PIPE"] = "fake"
+
+    # Call run_tests with project_root_path to simulate PROJECT_ROOT_PATH
+    actual = run_tests(
+        start_dir,
+        test_ids,
+        pattern,
+        None,
+        1,
+        None,
+        project_root_path=start_dir,
+    )
+
+    assert actual["status"] == "success"
+    # cwd in response should match the project_root_path (project root)
+    assert actual["cwd"] == os.fsdecode(project_path), (
+        f"Expected cwd '{os.fsdecode(project_path)}', got '{actual['cwd']}'"
+    )
+    assert actual["result"] is not None
+    assert test_ids[0] in actual["result"]
+    assert actual["result"][test_ids[0]]["outcome"] == "success"
+
+
+def test_project_root_path_with_different_cwd_and_start_dir(mock_send_run_data) -> None:  # noqa: ARG001
+    """Test unittest execution where project_root_path differs from start_dir.
+
+    This simulates the scenario where:
+    - start_dir points to a subfolder where tests are located
+    - project_root_path (PROJECT_ROOT_PATH) points to the project root
+
+    The cwd in the response should be the project root, while execution
+    still runs from the start_dir.
+    """
+    # Use utils_nested_cases as our test case
+    project_path = TEST_DATA_PATH / "utils_nested_cases"
+    start_dir = os.fsdecode(project_path)
+    pattern = "*"
+    test_ids = [
+        "file_one.CaseTwoFileOne.test_one",
+    ]
+
+    os.environ["TEST_RUN_PIPE"] = "fake"
+
+    # Call run_tests with project_root_path set to project root
+    actual = run_tests(
+        start_dir,
+        test_ids,
+        pattern,
+        None,
+        1,
+        None,
+        project_root_path=os.fsdecode(project_path),
+    )
+
+    assert actual["status"] == "success"
+    # cwd should be the project root (project_root_path)
+    assert actual["cwd"] == os.fsdecode(project_path), (
+        f"Expected cwd '{os.fsdecode(project_path)}', got '{actual['cwd']}'"
+    )
+    assert actual["result"] is not None
+    assert test_ids[0] in actual["result"]
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="Symlinks require elevated privileges on Windows",
+)
+def test_symlink_with_project_root_path(mock_send_run_data) -> None:  # noqa: ARG001
+    """Test unittest execution with both symlink and project_root_path set.
+
+    This tests the combination of:
+    1. A symlinked test directory
+    2. project_root_path (PROJECT_ROOT_PATH) set to the symlink path
+
+    This simulates project-based testing where the project root is a symlink,
+    ensuring execution payloads correctly use the symlink path.
+    """
+    with helpers.create_symlink(TEST_DATA_PATH, "unittest_folder", "symlink_unittest_exec") as (
+        _source,
+        destination,
+    ):
+        assert destination.is_symlink()
+
+        # Run execution with:
+        # - start_dir pointing to the symlink destination
+        # - project_root_path set to the symlink destination (simulating PROJECT_ROOT_PATH)
+        start_dir = os.fsdecode(destination)
+        pattern = "test_add*"
+        test_ids = [
+            "test_add.TestAddFunction.test_add_positive_numbers",
+        ]
+
+        os.environ["TEST_RUN_PIPE"] = "fake"
+
+        actual = run_tests(
+            start_dir,
+            test_ids,
+            pattern,
+            None,
+            1,
+            None,
+            project_root_path=start_dir,
+        )
+
+        assert actual["status"] == "success", (
+            f"Status is not 'success', error is: {actual.get('error')}"
+        )
+        # cwd should be the symlink path (project_root_path)
+        assert actual["cwd"] == os.fsdecode(destination), (
+            f"CWD does not match symlink path: expected {os.fsdecode(destination)}, got {actual['cwd']}"
+        )
diff --git a/python_files/tests/unittestadapter/test_utils.py b/python_files/tests/unittestadapter/test_utils.py
index b0341ce37b63..dc8a81175e70 100644
--- a/python_files/tests/unittestadapter/test_utils.py
+++ b/python_files/tests/unittestadapter/test_utils.py
@@ -284,11 +284,56 @@ def test_build_empty_tree() -> None:
     start_dir = os.fsdecode(TEST_DATA_PATH)
     pattern = "does_not_exist*"
 
-    expected = None
-
     loader = unittest.TestLoader()
     suite = loader.discover(start_dir, pattern)
     tests, errors = build_test_tree(suite, start_dir)
 
-    assert expected == tests
+    assert tests is not None
+    assert tests.get("children") == []
     assert not errors
+
+
+def test_doctest_standard_blocked() -> None:
+    """Standard doctests with short IDs should be skipped with an error message."""
+    start_dir = os.fsdecode(TEST_DATA_PATH)
+    pattern = "test_doctest_standard*"
+
+    loader = unittest.TestLoader()
+    suite = loader.discover(start_dir, pattern)
+    tests, errors = build_test_tree(suite, start_dir)
+
+    # Should return a tree but with no test children (since doctests are skipped)
+    assert tests is not None
+    # Check that we got an error about doctests not being supported
+    assert len(errors) > 0
+    assert "Skipping doctest as it is not supported for the extension" in errors[0]
+
+
+def test_doctest_patched_works() -> None:
+    """Patched doctests with properly formatted IDs should be processed normally."""
+    start_dir = os.fsdecode(TEST_DATA_PATH)
+    pattern = "test_doctest_patched*"
+
+    loader = unittest.TestLoader()
+    suite = loader.discover(start_dir, pattern)
+    tests, errors = build_test_tree(suite, start_dir)
+
+    # Should successfully build a tree with the patched doctest
+    assert tests is not None
+
+    # The patched doctests should have proper IDs and be included
+    # We should find at least one test child (the doctests that were patched)
+    def count_tests(node):
+        """Recursively count test nodes."""
+        if node.get("type_") == "test":
+            return 1
+        count = 0
+        for child in node.get("children", []):
+            count += count_tests(child)
+        return count
+
+    test_count = count_tests(tests)
+    # We expect at least the module doctest and function doctest
+    assert test_count > 0, "Patched doctests should be included in the tree"
+    # Should not have doctest-related errors since they're properly formatted
+    assert not any("doctest" in str(e).lower() for e in errors)
diff --git a/python_files/unittestadapter/discovery.py b/python_files/unittestadapter/discovery.py
index ce8251218743..c864ac76916b 100644
--- a/python_files/unittestadapter/discovery.py
+++ b/python_files/unittestadapter/discovery.py
@@ -27,12 +27,13 @@ def discover_tests(
     start_dir: str,
     pattern: str,
     top_level_dir: Optional[str],
+    project_root_path: Optional[str] = None,
 ) -> DiscoveryPayloadDict:
     """Returns a dictionary containing details of the discovered tests.
 
     The returned dict has the following keys:
 
-    - cwd: Absolute path to the test start directory;
+    - cwd: Absolute path to the test start directory (or project_root_path if provided);
     - status: Test discovery status, can be "success" or "error";
     - tests: Discoverered tests if any, not present otherwise. Note that the status can be "error" but the payload can still contain tests;
     - error: Discovery error if any, not present otherwise.
@@ -56,8 +57,15 @@ def discover_tests(
         "": [list of errors]
         "status": "error",
     }
+
+    Args:
+        start_dir: Directory where test discovery starts
+        pattern: Pattern to match test files (e.g., "test*.py")
+        top_level_dir: Top-level directory for the test tree hierarchy
+        project_root_path: Optional project root path for the cwd in the response payload
+                          (used for project-based testing to root test tree at project)
     """
-    cwd = os.path.abspath(start_dir)  # noqa: PTH100
+    cwd = os.path.abspath(project_root_path or start_dir)  # noqa: PTH100
     if "/" in start_dir:  #  is a subdir
         parent_dir = os.path.dirname(start_dir)  # noqa: PTH120
         sys.path.insert(0, parent_dir)
@@ -133,7 +141,16 @@ def discover_tests(
             print(error_msg, file=sys.stderr)
             raise VSCodeUnittestError(error_msg)  # noqa: B904
     else:
+        # Check for PROJECT_ROOT_PATH environment variable (project-based testing).
+        # When set, this overrides top_level_dir to root the test tree at the project directory.
+        project_root_path = os.environ.get("PROJECT_ROOT_PATH")
+        if project_root_path:
+            top_level_dir = project_root_path
+
         # Perform regular unittest test discovery.
-        payload = discover_tests(start_dir, pattern, top_level_dir)
+        # Pass project_root_path so the payload's cwd matches the project root.
+        payload = discover_tests(
+            start_dir, pattern, top_level_dir, project_root_path=project_root_path
+        )
         # Post this discovery payload.
         send_post_request(payload, test_run_pipe)
diff --git a/python_files/unittestadapter/django_handler.py b/python_files/unittestadapter/django_handler.py
index 9daa816d0918..574aee7af7fa 100644
--- a/python_files/unittestadapter/django_handler.py
+++ b/python_files/unittestadapter/django_handler.py
@@ -5,7 +5,8 @@
 import pathlib
 import subprocess
 import sys
-from typing import List
+from contextlib import contextmanager, suppress
+from typing import Generator, List
 
 script_dir = pathlib.Path(__file__).parent
 sys.path.append(os.fspath(script_dir))
@@ -16,6 +17,17 @@
 )
 
 
+@contextmanager
+def override_argv(argv: List[str]) -> Generator:
+    """Context manager to temporarily override sys.argv with the provided arguments."""
+    original_argv = sys.argv
+    sys.argv = argv
+    try:
+        yield
+    finally:
+        sys.argv = original_argv
+
+
 def django_discovery_runner(manage_py_path: str, args: List[str]) -> None:
     # Attempt a small amount of validation on the manage.py path.
     if not pathlib.Path(manage_py_path).exists():
@@ -58,8 +70,9 @@ def django_discovery_runner(manage_py_path: str, args: List[str]) -> None:
 
 
 def django_execution_runner(manage_py_path: str, test_ids: List[str], args: List[str]) -> None:
+    manage_path: pathlib.Path = pathlib.Path(manage_py_path)
     # Attempt a small amount of validation on the manage.py path.
-    if not pathlib.Path(manage_py_path).exists():
+    if not manage_path.exists():
         raise VSCodeUnittestError("Error running Django, manage.py path does not exist.")
 
     try:
@@ -72,31 +85,27 @@ def django_execution_runner(manage_py_path: str, test_ids: List[str], args: List
         else:
             env["PYTHONPATH"] = os.fspath(custom_test_runner_dir)
 
-        # Build command to run 'python manage.py test'.
-        command: List[str] = [
-            sys.executable,
-            manage_py_path,
+        django_project_dir: pathlib.Path = manage_path.parent
+        sys.path.insert(0, os.fspath(django_project_dir))
+        print(f"Django project directory: {django_project_dir}")
+
+        manage_argv: List[str] = [
+            str(manage_path),
             "test",
             "--testrunner=django_test_runner.CustomExecutionTestRunner",
+            *args,
+            *test_ids,
         ]
-        # Add any additional arguments to the command provided by the user.
-        command.extend(args)
-        # Add the test_ids to the command.
-        print("Test IDs: ", test_ids)
-        print("args: ", args)
-        command.extend(test_ids)
-        print("Running Django run tests with command: ", command)
-        subprocess_execution = subprocess.run(
-            command,
-            capture_output=True,
-            text=True,
-            env=env,
-        )
-        print(subprocess_execution.stderr, file=sys.stderr)
-        print(subprocess_execution.stdout, file=sys.stdout)
-        # Zero return code indicates success, 1 indicates test failures, so both are considered successful.
-        if subprocess_execution.returncode not in (0, 1):
-            error_msg = "Django test execution process exited with non-zero error code See stderr above for more details."
-            print(error_msg, file=sys.stderr)
+        print(f"Django manage.py arguments: {manage_argv}")
+
+        try:
+            argv_context = override_argv(manage_argv)
+            suppress_context = suppress(SystemExit)
+            manage_file = manage_path.open()
+            with argv_context, suppress_context, manage_file:
+                manage_code = manage_file.read()
+                exec(manage_code, {"__name__": "__main__", "__file__": manage_path})
+        except OSError as e:
+            raise VSCodeUnittestError("Error running Django, unable to read manage.py") from e
     except Exception as e:
         print(f"Error during Django test execution: {e}", file=sys.stderr)
diff --git a/python_files/unittestadapter/execution.py b/python_files/unittestadapter/execution.py
index 644b233fc530..422f246d3476 100644
--- a/python_files/unittestadapter/execution.py
+++ b/python_files/unittestadapter/execution.py
@@ -36,6 +36,9 @@
 ErrorType = Union[Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None]]
 test_run_pipe = ""
 START_DIR = ""
+# PROJECT_ROOT_PATH: Used for project-based testing to override cwd in payload
+# When set, this should be used as the cwd in all execution payloads
+PROJECT_ROOT_PATH = None  # type: Optional[str]
 
 
 class TestOutcomeEnum(str, enum.Enum):
@@ -189,10 +192,24 @@ def run_tests(
     pattern: str,
     top_level_dir: Optional[str],
     verbosity: int,
-    failfast: Optional[bool],
-    locals_: Optional[bool] = None,
+    failfast: Optional[bool],  # noqa: FBT001
+    locals_: Optional[bool] = None,  # noqa: FBT001
+    project_root_path: Optional[str] = None,
 ) -> ExecutionPayloadDict:
-    cwd = os.path.abspath(start_dir)  # noqa: PTH100
+    """Run unittests and return the execution payload.
+
+    Args:
+        start_dir: Directory where test discovery starts
+        test_ids: List of test IDs to run
+        pattern: Pattern to match test files
+        top_level_dir: Top-level directory for test tree hierarchy
+        verbosity: Verbosity level for test output
+        failfast: Stop on first failure
+        locals_: Show local variables in tracebacks
+        project_root_path: Optional project root path for the cwd in the response payload
+                          (used for project-based testing to root test tree at project)
+    """
+    cwd = os.path.abspath(project_root_path or start_dir)  # noqa: PTH100
     if "/" in start_dir:  #  is a subdir
         parent_dir = os.path.dirname(start_dir)  # noqa: PTH120
         sys.path.insert(0, parent_dir)
@@ -259,7 +276,8 @@ def run_tests(
 
 def send_run_data(raw_data, test_run_pipe):
     status = raw_data["outcome"]
-    cwd = os.path.abspath(START_DIR)  # noqa: PTH100
+    # Use PROJECT_ROOT_PATH if set (project-based testing), otherwise use START_DIR
+    cwd = os.path.abspath(PROJECT_ROOT_PATH or START_DIR)  # noqa: PTH100
     test_id = raw_data["subtest"] or raw_data["test"]
     test_dict = {}
     test_dict[test_id] = raw_data
@@ -284,10 +302,10 @@ def send_run_data(raw_data, test_run_pipe):
     run_test_ids_pipe = os.environ.get("RUN_TEST_IDS_PIPE")
     test_run_pipe = os.getenv("TEST_RUN_PIPE")
     if not run_test_ids_pipe:
-        print("Error[vscode-unittest]: RUN_TEST_IDS_PIPE env var is not set.")
+        print("Error[vscode-unittest]: RUN_TEST_IDS_PIPE env var is not set.", file=sys.stderr)
         raise VSCodeUnittestError("Error[vscode-unittest]: RUN_TEST_IDS_PIPE env var is not set.")
     if not test_run_pipe:
-        print("Error[vscode-unittest]: TEST_RUN_PIPE env var is not set.")
+        print("Error[vscode-unittest]: TEST_RUN_PIPE env var is not set.", file=sys.stderr)
         raise VSCodeUnittestError("Error[vscode-unittest]: TEST_RUN_PIPE env var is not set.")
     test_ids = []
     cwd = pathlib.Path(start_dir).absolute()
@@ -295,11 +313,10 @@ def send_run_data(raw_data, test_run_pipe):
         # Read the test ids from the file, attempt to delete file afterwords.
         ids_path = pathlib.Path(run_test_ids_pipe)
         test_ids = ids_path.read_text(encoding="utf-8").splitlines()
-        print("Received test ids from temp file.")
         try:
             ids_path.unlink()
         except Exception as e:
-            print("Error[vscode-pytest]: unable to delete temp file" + str(e))
+            print(f"Error[vscode-unittest]: unable to delete temp file: {e}", file=sys.stderr)
 
     except Exception as e:
         # No test ids received from buffer, return error payload
@@ -316,13 +333,22 @@ def send_run_data(raw_data, test_run_pipe):
     # For unittest COVERAGE_ENABLED is to the root of the workspace so correct data is collected
     cov = None
     is_coverage_run = os.environ.get("COVERAGE_ENABLED") is not None
+    include_branches = False
     if is_coverage_run:
-        print(
-            "COVERAGE_ENABLED env var set, starting coverage. workspace_root used as parent dir:",
-            workspace_root,
-        )
         import coverage
 
+        # insert "python_files/lib/python" into the path so packaging can be imported
+        python_files_dir = pathlib.Path(__file__).parent.parent
+        bundled_dir = pathlib.Path(python_files_dir / "lib" / "python")
+        sys.path.append(os.fspath(bundled_dir))
+
+        from packaging.version import Version
+
+        coverage_version = Version(coverage.__version__)
+        # only include branches if coverage version is 7.7.0 or greater (as this was when the api saves)
+        if coverage_version >= Version("7.7.0"):
+            include_branches = True
+
         source_ar: List[str] = []
         if workspace_root:
             source_ar.append(workspace_root)
@@ -330,16 +356,26 @@ def send_run_data(raw_data, test_run_pipe):
             source_ar.append(top_level_dir)
         if start_dir:
             source_ar.append(os.path.abspath(start_dir))  # noqa: PTH100
-        cov = coverage.Coverage(branch=True, source=source_ar)  # is at least 1 of these required??
+        cov = coverage.Coverage(
+            branch=include_branches, source=source_ar
+        )  # is at least 1 of these required??
         cov.start()
 
     # If no error occurred, we will have test ids to run.
     if manage_py_path := os.environ.get("MANAGE_PY_PATH"):
-        print("MANAGE_PY_PATH env var set, running Django test suite.")
         args = argv[index + 1 :] or []
         django_execution_runner(manage_py_path, test_ids, args)
     else:
+        # Check for PROJECT_ROOT_PATH environment variable (project-based testing).
+        # When set, this overrides the cwd in the payload to match the project root.
+        project_root_path = os.environ.get("PROJECT_ROOT_PATH")
+        if project_root_path:
+            # Update the module-level variable for send_run_data to use
+            # pylint: disable=global-statement
+            globals()["PROJECT_ROOT_PATH"] = project_root_path
+
         # Perform regular unittest execution.
+        # Pass project_root_path so the payload's cwd matches the project root.
         payload = run_tests(
             start_dir,
             test_ids,
@@ -348,6 +384,7 @@ def send_run_data(raw_data, test_run_pipe):
             verbosity,
             failfast,
             locals_,
+            project_root_path=project_root_path,
         )
 
     if is_coverage_run:
@@ -362,12 +399,22 @@ def send_run_data(raw_data, test_run_pipe):
         file_coverage_map: Dict[str, FileCoverageInfo] = {}
         for file in file_set:
             analysis = cov.analysis2(file)
+            taken_file_branches = 0
+            total_file_branches = -1
+
+            if include_branches:
+                branch_stats: dict[int, tuple[int, int]] = cov.branch_stats(file)
+                total_file_branches = sum([total_exits for total_exits, _ in branch_stats.values()])
+                taken_file_branches = sum([taken_exits for _, taken_exits in branch_stats.values()])
+
             lines_executable = {int(line_no) for line_no in analysis[1]}
             lines_missed = {int(line_no) for line_no in analysis[3]}
             lines_covered = lines_executable - lines_missed
             file_info: FileCoverageInfo = {
                 "lines_covered": list(lines_covered),  # list of int
                 "lines_missed": list(lines_missed),  # list of int
+                "executed_branches": taken_file_branches,
+                "total_branches": total_file_branches,
             }
             file_coverage_map[file] = file_info
 
diff --git a/python_files/unittestadapter/pvsc_utils.py b/python_files/unittestadapter/pvsc_utils.py
index 4d1cbfb5e110..d6920592a4d4 100644
--- a/python_files/unittestadapter/pvsc_utils.py
+++ b/python_files/unittestadapter/pvsc_utils.py
@@ -3,6 +3,7 @@
 
 import argparse
 import atexit
+import doctest
 import enum
 import inspect
 import json
@@ -43,6 +44,7 @@ class TestItem(TestData):
 
 class TestNode(TestData):
     children: "List[TestNode | TestItem]"
+    lineno: NotRequired[str]  # Optional field for class nodes
 
 
 class TestExecutionStatus(str, enum.Enum):
@@ -75,6 +77,8 @@ class ExecutionPayloadDict(TypedDict):
 class FileCoverageInfo(TypedDict):
     lines_covered: List[int]
     lines_missed: List[int]
+    executed_branches: int
+    total_branches: int
 
 
 class CoveragePayloadDict(Dict):
@@ -98,6 +102,16 @@ def get_test_case(suite):
             yield from get_test_case(test)
 
 
+def get_class_line(test_case: unittest.TestCase) -> Optional[str]:
+    """Get the line number where a test class is defined."""
+    try:
+        test_class = test_case.__class__
+        _sourcelines, lineno = inspect.getsourcelines(test_class)
+        return str(lineno)
+    except Exception:
+        return None
+
+
 def get_source_line(obj) -> str:
     """Get the line number of a test case start line."""
     try:
@@ -212,6 +226,14 @@ def build_test_tree(
         else:
             # Get the static test path components: filename, class name and function name.
             components = test_id.split(".")
+            # Check if this is a doctest with insufficient components that would cause unpacking to fail
+            if len(components) < 3 and isinstance(test_case, doctest.DocTestCase):
+                print(
+                    "Skipping doctest as it is not supported for the extension. Test case: ",
+                    test_case,
+                )
+                error = ["Skipping doctest as it is not supported for the extension."]
+                continue
             *folders, filename, class_name, function_name = components
             py_filename = f"{filename}.py"
 
@@ -238,6 +260,12 @@ def build_test_tree(
                 class_name, file_path, TestNodeTypeEnum.class_, current_node
             )
 
+            # Add line number to class node if not already present.
+            if "lineno" not in current_node:
+                class_lineno = get_class_line(test_case)
+                if class_lineno is not None:
+                    current_node["lineno"] = class_lineno
+
             # Get test line number.
             test_method = getattr(test_case, test_case._testMethodName)  # noqa: SLF001
             lineno = get_source_line(test_method)
@@ -253,9 +281,6 @@ def build_test_tree(
             }  # concatenate class name and function test name
             current_node["children"].append(test_node)
 
-    if not root["children"]:
-        root = None
-
     return root, error
 
 
diff --git a/python_files/vscode_pytest/__init__.py b/python_files/vscode_pytest/__init__.py
index 00f356e20dcd..be4e3daaa843 100644
--- a/python_files/vscode_pytest/__init__.py
+++ b/python_files/vscode_pytest/__init__.py
@@ -10,13 +10,22 @@
 import pathlib
 import sys
 import traceback
-from typing import TYPE_CHECKING, Any, Dict, Generator, Literal, TypedDict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    Literal,
+    Protocol,
+    TypedDict,
+    cast,
+)
 
 import pytest
 
 if TYPE_CHECKING:
     from pluggy import Result
-
+    from typing_extensions import NotRequired
 
 USES_PYTEST_DESCRIBE = False
 
@@ -26,6 +35,13 @@
     USES_PYTEST_DESCRIBE = True
 
 
+class HasPathOrFspath(Protocol):
+    """Protocol defining objects that have either a path or fspath attribute."""
+
+    path: pathlib.Path | None = None
+    fspath: Any | None = None
+
+
 class TestData(TypedDict):
     """A general class that all test objects inherit from."""
 
@@ -46,6 +62,7 @@ class TestNode(TestData):
     """A general class that handles all test data which contains children."""
 
     children: list[TestNode | TestItem | None]
+    lineno: NotRequired[str]  # Optional field for class/function nodes
 
 
 class VSCodePytestError(Exception):
@@ -58,18 +75,46 @@ def __init__(self, message):
 ERRORS = []
 IS_DISCOVERY = False
 map_id_to_path = {}
-collected_tests_so_far = []
+collected_tests_so_far = set()
 TEST_RUN_PIPE = os.getenv("TEST_RUN_PIPE")
+PROJECT_ROOT_PATH = os.getenv(
+    "PROJECT_ROOT_PATH"
+)  # Path to project root for multi-project workspaces
 SYMLINK_PATH = None
+INCLUDE_BRANCHES = False
+
+# Performance optimization caches for path resolution
+_path_cache: dict[int, pathlib.Path] = {}  # Cache node paths by object id
+_path_to_str_cache: dict[pathlib.Path, str] = {}  # Cache path-to-string conversions
+_CACHED_CWD: pathlib.Path | None = None
+
+
+def get_test_root_path() -> pathlib.Path:
+    """Get the root path for the test tree.
+
+    For project-based testing, this returns PROJECT_ROOT_PATH (the project root).
+    For legacy mode, this returns the current working directory.
+
+    Returns:
+        pathlib.Path: The root path to use for the test tree.
+    """
+    if PROJECT_ROOT_PATH:
+        return pathlib.Path(PROJECT_ROOT_PATH)
+    return pathlib.Path.cwd()
 
 
 def pytest_load_initial_conftests(early_config, parser, args):  # noqa: ARG001
-    has_pytest_cov = early_config.pluginmanager.hasplugin("pytest_cov")
+    has_pytest_cov = early_config.pluginmanager.hasplugin(
+        "pytest_cov"
+    ) or early_config.pluginmanager.hasplugin("pytest_cov.plugin")
     has_cov_arg = any("--cov" in arg for arg in args)
     if has_cov_arg and not has_pytest_cov:
         raise VSCodePytestError(
             "\n \nERROR: pytest-cov is not installed, please install this before running pytest with coverage as pytest-cov is required. \n"
         )
+    if "--cov-branch" in args:
+        global INCLUDE_BRANCHES
+        INCLUDE_BRANCHES = True
 
     global TEST_RUN_PIPE
     TEST_RUN_PIPE = os.getenv("TEST_RUN_PIPE")
@@ -121,7 +166,7 @@ def pytest_internalerror(excrepr, excinfo):  # noqa: ARG001
     excinfo -- the exception information of type ExceptionInfo.
     """
     # call.excinfo.exconly() returns the exception as a string.
-    ERRORS.append(excinfo.exconly() + "\n Check Python Test Logs for more details.")
+    ERRORS.append(excinfo.exconly() + "\n Check Python Logs for more details.")
 
 
 def pytest_exception_interact(node, call, report):
@@ -139,9 +184,9 @@ def pytest_exception_interact(node, call, report):
         if call.excinfo and call.excinfo.typename != "AssertionError":
             if report.outcome == "skipped" and "SkipTest" in str(call):
                 return
-            ERRORS.append(call.excinfo.exconly() + "\n Check Python Test Logs for more details.")
+            ERRORS.append(call.excinfo.exconly() + "\n Check Python Logs for more details.")
         else:
-            ERRORS.append(report.longreprtext + "\n Check Python Test Logs for more details.")
+            ERRORS.append(report.longreprtext + "\n Check Python Logs for more details.")
     else:
         # If during execution, send this data that the given node failed.
         report_value = "error"
@@ -149,7 +194,7 @@ def pytest_exception_interact(node, call, report):
             report_value = "failure"
         node_id = get_absolute_test_id(node.nodeid, get_node_path(node))
         if node_id not in collected_tests_so_far:
-            collected_tests_so_far.append(node_id)
+            collected_tests_so_far.add(node_id)
             item_result = create_test_outcome(
                 node_id,
                 report_value,
@@ -162,7 +207,7 @@ def pytest_exception_interact(node, call, report):
             send_execution_message(
                 os.fsdecode(cwd),
                 "success",
-                collected_test if collected_test else None,
+                collected_test or None,
             )
 
 
@@ -204,7 +249,7 @@ def pytest_keyboard_interrupt(excinfo):
     excinfo -- the exception information of type ExceptionInfo.
     """
     # The function execonly() returns the exception as a string.
-    ERRORS.append(excinfo.exconly() + "\n Check Python Test Logs for more details.")
+    ERRORS.append(excinfo.exconly() + "\n Check Python Logs for more details.")
 
 
 class TestOutcome(Dict):
@@ -274,7 +319,7 @@ def pytest_report_teststatus(report, config):  # noqa: ARG001
         # Calculate the absolute test id and use this as the ID moving forward.
         absolute_node_id = get_absolute_test_id(report.nodeid, node_path)
         if absolute_node_id not in collected_tests_so_far:
-            collected_tests_so_far.append(absolute_node_id)
+            collected_tests_so_far.add(absolute_node_id)
             item_result = create_test_outcome(
                 absolute_node_id,
                 report_value,
@@ -286,7 +331,7 @@ def pytest_report_teststatus(report, config):  # noqa: ARG001
             send_execution_message(
                 os.fsdecode(cwd),
                 "success",
-                collected_test if collected_test else None,
+                collected_test or None,
             )
     yield
 
@@ -308,7 +353,7 @@ def pytest_runtest_protocol(item, nextitem):  # noqa: ARG001
         report_value = "skipped"
         cwd = pathlib.Path.cwd()
         if absolute_node_id not in collected_tests_so_far:
-            collected_tests_so_far.append(absolute_node_id)
+            collected_tests_so_far.add(absolute_node_id)
             item_result = create_test_outcome(
                 absolute_node_id,
                 report_value,
@@ -320,7 +365,7 @@ def pytest_runtest_protocol(item, nextitem):  # noqa: ARG001
             send_execution_message(
                 os.fsdecode(cwd),
                 "success",
-                collected_test if collected_test else None,
+                collected_test or None,
             )
     yield
 
@@ -363,6 +408,8 @@ def check_skipped_condition(item):
 class FileCoverageInfo(TypedDict):
     lines_covered: list[int]
     lines_missed: list[int]
+    executed_branches: int
+    total_branches: int
 
 
 def pytest_sessionfinish(session, exitstatus):
@@ -379,21 +426,23 @@ def pytest_sessionfinish(session, exitstatus):
     Exit code 4: pytest command line usage error
     Exit code 5: No tests were collected
     """
-    cwd = pathlib.Path.cwd()
+    # Get the root path for the test tree structure (not the CWD for test execution)
+    # This is PROJECT_ROOT_PATH in project-based mode, or cwd in legacy mode
+    test_root_path = get_test_root_path()
     if SYMLINK_PATH:
-        print("Plugin warning[vscode-pytest]: SYMLINK set, adjusting cwd.")
-        cwd = pathlib.Path(SYMLINK_PATH)
+        print("Plugin warning[vscode-pytest]: SYMLINK set, adjusting test root path.")
+        test_root_path = pathlib.Path(SYMLINK_PATH)
 
     if IS_DISCOVERY:
         if not (exitstatus == 0 or exitstatus == 1 or exitstatus == 5):
             error_node: TestNode = {
                 "name": "",
-                "path": cwd,
+                "path": test_root_path,
                 "type_": "error",
                 "children": [],
                 "id_": "",
             }
-            send_discovery_message(os.fsdecode(cwd), error_node)
+            send_discovery_message(os.fsdecode(test_root_path), error_node)
         try:
             session_node: TestNode | None = build_test_tree(session)
             if not session_node:
@@ -401,19 +450,19 @@ def pytest_sessionfinish(session, exitstatus):
                     "Something went wrong following pytest finish, \
                         no session node was created"
                 )
-            send_discovery_message(os.fsdecode(cwd), session_node)
+            send_discovery_message(os.fsdecode(test_root_path), session_node)
         except Exception as e:
             ERRORS.append(
                 f"Error Occurred, traceback: {(traceback.format_exc() if e.__traceback__ else '')}"
             )
             error_node: TestNode = {
                 "name": "",
-                "path": cwd,
+                "path": test_root_path,
                 "type_": "error",
                 "children": [],
                 "id_": "",
             }
-            send_discovery_message(os.fsdecode(cwd), error_node)
+            send_discovery_message(os.fsdecode(test_root_path), error_node)
     else:
         if exitstatus == 0 or exitstatus == 1:
             exitstatus_bool = "success"
@@ -424,7 +473,7 @@ def pytest_sessionfinish(session, exitstatus):
             exitstatus_bool = "error"
 
             send_execution_message(
-                os.fsdecode(cwd),
+                os.fsdecode(test_root_path),
                 exitstatus_bool,
                 None,
             )
@@ -436,6 +485,22 @@ def pytest_sessionfinish(session, exitstatus):
         # load the report and build the json result to return
         import coverage
 
+        # insert "python_files/lib/python" into the path so packaging can be imported
+        python_files_dir = pathlib.Path(__file__).parent.parent
+        bundled_dir = pathlib.Path(python_files_dir / "lib" / "python")
+        sys.path.append(os.fspath(bundled_dir))
+
+        from packaging.version import Version
+
+        coverage_version = Version(coverage.__version__)
+        global INCLUDE_BRANCHES
+        # only include branches if coverage version is 7.7.0 or greater (as this was when the api saves)
+        if coverage_version < Version("7.7.0") and INCLUDE_BRANCHES:
+            print(
+                "Plugin warning[vscode-pytest]: Branch coverage not supported in this coverage versions < 7.7.0. Please upgrade coverage package if you would like to see branch coverage."
+            )
+            INCLUDE_BRANCHES = False
+
         try:
             from coverage.exceptions import NoSource
         except ImportError:
@@ -448,9 +513,8 @@ def pytest_sessionfinish(session, exitstatus):
         file_coverage_map: dict[str, FileCoverageInfo] = {}
 
         # remove files omitted per coverage report config if any
-        omit_files = cov.config.report_omit
-        if omit_files:
-            print("Plugin info[vscode-pytest]: Omit files/rules: ", omit_files)
+        omit_files: list[str] | None = cov.config.report_omit
+        if omit_files is not None:
             for pattern in omit_files:
                 for file in list(file_set):
                     if pathlib.Path(file).match(pattern):
@@ -459,6 +523,18 @@ def pytest_sessionfinish(session, exitstatus):
         for file in file_set:
             try:
                 analysis = cov.analysis2(file)
+                taken_file_branches = 0
+                total_file_branches = -1
+
+                if INCLUDE_BRANCHES:
+                    branch_stats: dict[int, tuple[int, int]] = cov.branch_stats(file)
+                    total_file_branches = sum(
+                        [total_exits for total_exits, _ in branch_stats.values()]
+                    )
+                    taken_file_branches = sum(
+                        [taken_exits for _, taken_exits in branch_stats.values()]
+                    )
+
             except NoSource:
                 # as per issue 24308 this best way to handle this edge case
                 continue
@@ -473,23 +549,148 @@ def pytest_sessionfinish(session, exitstatus):
             file_info: FileCoverageInfo = {
                 "lines_covered": list(lines_covered),  # list of int
                 "lines_missed": list(lines_missed),  # list of int
+                "executed_branches": taken_file_branches,
+                "total_branches": total_file_branches,
             }
+            # convert relative path to absolute path
+            if not pathlib.Path(file).is_absolute():
+                file = str(pathlib.Path(file).resolve())
             file_coverage_map[file] = file_info
 
         payload: CoveragePayloadDict = CoveragePayloadDict(
             coverage=True,
-            cwd=os.fspath(cwd),
+            cwd=os.fspath(test_root_path),
             result=file_coverage_map,
             error=None,
         )
         send_message(payload)
 
 
+def construct_nested_folders(
+    file_nodes_dict: dict[str, TestNode],
+    session_node: TestNode,
+    session_children_dict: dict[str, TestNode],
+) -> dict[str, TestNode]:
+    """Iterate through all files and construct them into nested folders.
+
+    Keyword arguments:
+    file_nodes_dict -- Dictionary of all file nodes
+    session_node -- The session node that will be parent to the folder structure
+    session_children_dict -- Dictionary of session's children nodes indexed by ID
+
+    Returns:
+    dict[str, TestNode] -- Updated session_children_dict with folder nodes added
+    """
+    created_files_folders_dict: dict[str, TestNode] = {}
+    for file_node in file_nodes_dict.values():
+        # Iterate through all the files that exist and construct them into nested folders.
+        root_folder_node: TestNode
+        try:
+            root_folder_node: TestNode = build_nested_folders(
+                file_node, created_files_folders_dict, session_node
+            )
+        except ValueError:
+            # This exception is raised when the session node is not a parent of the file node.
+            print(
+                "[vscode-pytest]: Session path not a parent of test paths, adjusting session node to common parent."
+            )
+            file_path_str: str = str(file_node["path"])
+            session_path_str: str = str(session_node["path"])
+            common_parent = os.path.commonpath([file_path_str, session_path_str])
+            common_parent_path = pathlib.Path(common_parent)
+            print("[vscode-pytest]: Session node now set to: ", common_parent)
+            session_node["path"] = common_parent_path  # pathlib.Path
+            session_node["id_"] = common_parent  # str
+            session_node["name"] = common_parent_path.name  # str
+            root_folder_node = build_nested_folders(
+                file_node, created_files_folders_dict, session_node
+            )
+        # The final folder we get to is the highest folder in the path
+        # and therefore we add this as a child to the session.
+        root_id = root_folder_node.get("id_")
+        if root_id and root_id not in session_children_dict:
+            session_children_dict[root_id] = root_folder_node
+
+    return session_children_dict
+
+
+def process_parameterized_test(
+    test_case: pytest.Item,
+    test_node: TestItem,
+    function_nodes_dict: dict[str, TestNode],
+    file_nodes_dict: dict[str, TestNode],
+) -> TestNode:
+    """Process a parameterized test case and create appropriate function nodes.
+
+    Keyword arguments:
+    test_case -- the parameterized pytest test case; must have callspec attribute
+    test_node -- the test node created from the test case
+    function_nodes_dict -- dictionary of function nodes indexed by ID
+    file_nodes_dict -- dictionary of file nodes indexed by path
+
+    Returns:
+    TestNode -- the node to use for further processing (function node or original test node)
+    """
+    function_name: str = ""
+    # parameterized test cases cut the repetitive part of the name off.
+    parent_part, parameterized_section = test_node["name"].split("[", 1)
+    test_node["name"] = "[" + parameterized_section
+
+    first_split = test_case.nodeid.rsplit(
+        "::", 1
+    )  # splits the parameterized test name from the rest of the nodeid
+    second_split = first_split[0].rsplit(
+        ".py", 1
+    )  # splits the file path from the rest of the nodeid
+
+    class_and_method = second_split[1] + "::"  # This has "::" separator at both ends
+    # construct the parent id, so it is absolute path :: any class and method :: parent_part
+    parent_id = cached_fsdecode(get_node_path(test_case)) + class_and_method + parent_part
+
+    try:
+        function_name = test_case.originalname  # type: ignore
+    except AttributeError:  # actual error has occurred
+        ERRORS.append(
+            f"unable to find original name for {test_case.name} with parameterization detected."
+        )
+        raise VSCodePytestError(
+            "Unable to find original name for parameterized test case"
+        ) from None
+
+    function_test_node = function_nodes_dict.get(parent_id)
+    if function_test_node is None:
+        function_test_node = create_parameterized_function_node(
+            function_name, get_node_path(test_case), parent_id
+        )
+        function_nodes_dict[parent_id] = function_test_node
+
+    if test_node not in function_test_node["children"]:
+        function_test_node["children"].append(test_node)
+
+    # Check if the parent node of the function is file, if so create/add to this file node.
+    if isinstance(test_case.parent, pytest.File):
+        # calculate the parent path of the test case
+        parent_path = get_node_path(test_case.parent)
+        parent_path_key = cached_fsdecode(parent_path)
+        parent_test_case = file_nodes_dict.get(parent_path_key)
+        if parent_test_case is None:
+            parent_test_case = create_file_node(parent_path)
+            file_nodes_dict[parent_path_key] = parent_test_case
+        if function_test_node not in parent_test_case["children"]:
+            parent_test_case["children"].append(function_test_node)
+
+    # Return the function node as the test node to handle subsequent nesting
+    return function_test_node
+
+
 def build_test_tree(session: pytest.Session) -> TestNode:
     """Builds a tree made up of testing nodes from the pytest session.
 
     Keyword arguments:
-    session -- the pytest session object.
+    session -- the pytest session object that contains test items.
+
+    Returns:
+    TestNode -- The root node of the constructed test tree.
     """
     session_node = create_session_node(session)
     session_children_dict: dict[str, TestNode] = {}
@@ -505,54 +706,10 @@ def build_test_tree(session: pytest.Session) -> TestNode:
     for test_case in session.items:
         test_node = create_test_node(test_case)
         if hasattr(test_case, "callspec"):  # This means it is a parameterized test.
-            function_name: str = ""
-            # parameterized test cases cut the repetitive part of the name off.
-            parent_part, parameterized_section = test_node["name"].split("[", 1)
-            test_node["name"] = "[" + parameterized_section
-
-            first_split = test_case.nodeid.rsplit(
-                "::", 1
-            )  # splits the parameterized test name from the rest of the nodeid
-            second_split = first_split[0].rsplit(
-                ".py", 1
-            )  # splits the file path from the rest of the nodeid
-
-            class_and_method = second_split[1] + "::"  # This has "::" separator at both ends
-            # construct the parent id, so it is absolute path :: any class and method :: parent_part
-            parent_id = os.fspath(get_node_path(test_case)) + class_and_method + parent_part
-            # file, middle, param = test_case.nodeid.rsplit("::", 2)
-            # parent_id = test_case.nodeid.rsplit("::", 1)[0] + "::" + parent_part
-            # parent_path = os.fspath(get_node_path(test_case)) + "::" + parent_part
-            try:
-                function_name = test_case.originalname  # type: ignore
-                function_test_node = function_nodes_dict[parent_id]
-            except AttributeError:  # actual error has occurred
-                ERRORS.append(
-                    f"unable to find original name for {test_case.name} with parameterization detected."
-                )
-                raise VSCodePytestError(
-                    "Unable to find original name for parameterized test case"
-                ) from None
-            except KeyError:
-                function_test_node: TestNode = create_parameterized_function_node(
-                    function_name, get_node_path(test_case), parent_id
-                )
-                function_nodes_dict[parent_id] = function_test_node
-            if test_node not in function_test_node["children"]:
-                function_test_node["children"].append(test_node)
-            # Check if the parent node of the function is file, if so create/add to this file node.
-            if isinstance(test_case.parent, pytest.File):
-                # calculate the parent path of the test case
-                parent_path = get_node_path(test_case.parent)
-                try:
-                    parent_test_case = file_nodes_dict[os.fspath(parent_path)]
-                except KeyError:
-                    parent_test_case = create_file_node(parent_path)
-                    file_nodes_dict[os.fspath(parent_path)] = parent_test_case
-                if function_test_node not in parent_test_case["children"]:
-                    parent_test_case["children"].append(function_test_node)
-            # If the parent is not a file, it is a class, add the function node as the test node to handle subsequent nesting.
-            test_node = function_test_node
+            # Process parameterized test and get the function node to use for further processing
+            test_node = process_parameterized_test(
+                test_case, test_node, function_nodes_dict, file_nodes_dict
+            )
         if isinstance(test_case.parent, pytest.Class) or (
             USES_PYTEST_DESCRIBE and isinstance(test_case.parent, DescribeBlock)
         ):
@@ -563,9 +720,8 @@ def build_test_tree(session: pytest.Session) -> TestNode:
                 USES_PYTEST_DESCRIBE and isinstance(case_iter, DescribeBlock)
             ):
                 # While the given node is a class, create a class and nest the previous node as a child.
-                try:
-                    test_class_node = class_nodes_dict[case_iter.nodeid]
-                except KeyError:
+                test_class_node = class_nodes_dict.get(case_iter.nodeid)
+                if test_class_node is None:
                     test_class_node = create_class_node(case_iter)
                     class_nodes_dict[case_iter.nodeid] = test_class_node
                 # Check if the class already has the child node. This will occur if the test is parameterized.
@@ -582,50 +738,35 @@ def build_test_tree(session: pytest.Session) -> TestNode:
                 break
             parent_path = get_node_path(parent_module)
             # Create a file node that has the last class as a child.
-            try:
-                test_file_node: TestNode = file_nodes_dict[os.fspath(parent_path)]
-            except KeyError:
+            parent_path_key = cached_fsdecode(parent_path)
+            test_file_node = file_nodes_dict.get(parent_path_key)
+            if test_file_node is None:
                 test_file_node = create_file_node(parent_path)
-                file_nodes_dict[os.fspath(parent_path)] = test_file_node
+                file_nodes_dict[parent_path_key] = test_file_node
             # Check if the class is already a child of the file node.
             if test_class_node is not None and test_class_node not in test_file_node["children"]:
                 test_file_node["children"].append(test_class_node)
         elif not hasattr(test_case, "callspec"):
             # This includes test cases that are pytest functions or a doctests.
-            parent_path = get_node_path(test_case.parent)
-            try:
-                parent_test_case = file_nodes_dict[os.fspath(parent_path)]
-            except KeyError:
+            if test_case.parent is None:
+                ERRORS.append(f"Test case {test_case.name} has no parent")
+                continue
+            parent_path = get_node_path(
+                cast(
+                    "pytest.Session | pytest.Item | pytest.File | pytest.Class | pytest.Module | HasPathOrFspath",
+                    test_case.parent,
+                )
+            )
+            parent_path_key = cached_fsdecode(parent_path)
+            parent_test_case = file_nodes_dict.get(parent_path_key)
+            if parent_test_case is None:
                 parent_test_case = create_file_node(parent_path)
-                file_nodes_dict[os.fspath(parent_path)] = parent_test_case
+                file_nodes_dict[parent_path_key] = parent_test_case
             parent_test_case["children"].append(test_node)
-    created_files_folders_dict: dict[str, TestNode] = {}
-    for file_node in file_nodes_dict.values():
-        # Iterate through all the files that exist and construct them into nested folders.
-        root_folder_node: TestNode
-        try:
-            root_folder_node: TestNode = build_nested_folders(
-                file_node, created_files_folders_dict, session_node
-            )
-        except ValueError:
-            # This exception is raised when the session node is not a parent of the file node.
-            print(
-                "[vscode-pytest]: Session path not a parent of test paths, adjusting session node to common parent."
-            )
-            common_parent = os.path.commonpath([file_node["path"], get_node_path(session)])
-            common_parent_path = pathlib.Path(common_parent)
-            print("[vscode-pytest]: Session node now set to: ", common_parent)
-            session_node["path"] = common_parent_path  # pathlib.Path
-            session_node["id_"] = common_parent  # str
-            session_node["name"] = common_parent_path.name  # str
-            root_folder_node = build_nested_folders(
-                file_node, created_files_folders_dict, session_node
-            )
-        # The final folder we get to is the highest folder in the path
-        # and therefore we add this as a child to the session.
-        root_id = root_folder_node.get("id_")
-        if root_id and root_id not in session_children_dict:
-            session_children_dict[root_id] = root_folder_node
+    # Process all files and construct them into nested folders
+    session_children_dict = construct_nested_folders(
+        file_nodes_dict, session_node, session_children_dict
+    )
     session_node["children"] = list(session_children_dict.values())
     return session_node
 
@@ -661,11 +802,11 @@ def build_nested_folders(
     max_iter = 100
     while iterator_path != session_node_path:
         curr_folder_name = iterator_path.name
-        try:
-            curr_folder_node: TestNode = created_files_folders_dict[os.fspath(iterator_path)]
-        except KeyError:
-            curr_folder_node: TestNode = create_folder_node(curr_folder_name, iterator_path)
-            created_files_folders_dict[os.fspath(iterator_path)] = curr_folder_node
+        iterator_path_key = cached_fsdecode(iterator_path)
+        curr_folder_node = created_files_folders_dict.get(iterator_path_key)
+        if curr_folder_node is None:
+            curr_folder_node = create_folder_node(curr_folder_name, iterator_path)
+            created_files_folders_dict[iterator_path_key] = curr_folder_node
         if prev_folder_node not in curr_folder_node["children"]:
             curr_folder_node["children"].append(prev_folder_node)
         iterator_path = iterator_path.parent
@@ -710,7 +851,8 @@ def create_session_node(session: pytest.Session) -> TestNode:
     Keyword arguments:
     session -- the pytest session.
     """
-    node_path = get_node_path(session)
+    # Use PROJECT_ROOT_PATH if set (project-based testing), otherwise use session path (legacy)
+    node_path = pathlib.Path(PROJECT_ROOT_PATH) if PROJECT_ROOT_PATH else get_node_path(session)
     return {
         "name": node_path.name,
         "path": node_path,
@@ -726,12 +868,25 @@ def create_class_node(class_module: pytest.Class | DescribeBlock) -> TestNode:
     Keyword arguments:
     class_module -- the pytest object representing a class module.
     """
+    # Get line number for the class definition
+    class_line = ""
+    try:
+        if hasattr(class_module, "obj"):
+            import inspect
+
+            _, lineno = inspect.getsourcelines(class_module.obj)
+            class_line = str(lineno)
+    except (OSError, TypeError):
+        # If we can't get the source lines, leave lineno empty
+        pass
+
     return {
         "name": class_module.name,
         "path": get_node_path(class_module),
         "type_": "class",
         "children": [],
-        "id_": class_module.nodeid,
+        "id_": get_absolute_test_id(class_module.nodeid, get_node_path(class_module)),
+        "lineno": class_line,
     }
 
 
@@ -814,12 +969,50 @@ class CoveragePayloadDict(Dict):
     error: str | None  # Currently unused need to check
 
 
-def get_node_path(node: Any) -> pathlib.Path:
+def cached_fsdecode(path: pathlib.Path) -> str:
+    """Convert path to string with caching for performance.
+
+    This function caches path-to-string conversions to avoid redundant
+    os.fsdecode() calls during test tree building.
+
+    Parameters:
+        path: The pathlib.Path object to convert to string.
+
+    Returns:
+        str: The string representation of the path.
+    """
+    if path not in _path_to_str_cache:
+        _path_to_str_cache[path] = os.fspath(path)
+    return _path_to_str_cache[path]
+
+
+def get_node_path(
+    node: pytest.Session
+    | pytest.Item
+    | pytest.File
+    | pytest.Class
+    | pytest.Module
+    | HasPathOrFspath,
+) -> pathlib.Path:
     """A function that returns the path of a node given the switch to pathlib.Path.
 
     It also evaluates if the node is a symlink and returns the equivalent path.
+
+    Parameters:
+        node: A pytest object or any object that has a path or fspath attribute.
+            Do NOT pass a pathlib.Path object directly; use it directly instead.
+
+    Returns:
+        pathlib.Path: The resolved path for the node.
     """
-    node_path = getattr(node, "path", None) or pathlib.Path(node.fspath)
+    cache_key = id(node)
+    if cache_key in _path_cache:
+        return _path_cache[cache_key]
+
+    node_path = getattr(node, "path", None)
+    if node_path is None:
+        fspath = getattr(node, "fspath", None)
+        node_path = pathlib.Path(fspath) if fspath is not None else None
 
     if not node_path:
         raise VSCodePytestError(
@@ -831,22 +1024,34 @@ def get_node_path(node: Any) -> pathlib.Path:
         # Get relative between the cwd (resolved path) and the node path.
         try:
             # Check to see if the node path contains the symlink root already
-            common_path = os.path.commonpath([SYMLINK_PATH, node_path])
+            # Convert Path objects to strings for os.path.commonpath
+            symlink_str: str = str(SYMLINK_PATH)
+            node_path_str: str = str(node_path)
+            common_path = os.path.commonpath([symlink_str, node_path_str])
             if common_path == os.fsdecode(SYMLINK_PATH):
                 # The node path is already relative to the SYMLINK_PATH root therefore return
-                return node_path
+                result = node_path
             else:
                 # If the node path is not a symlink, then we need to calculate the equivalent symlink path
                 # get the relative path between the cwd and the node path (as the node path is not a symlink).
-                rel_path = node_path.relative_to(pathlib.Path.cwd())
+                # Use cached cwd to avoid repeated system calls
+                global _CACHED_CWD
+                if _CACHED_CWD is None:
+                    _CACHED_CWD = pathlib.Path.cwd()
+                rel_path = node_path.relative_to(_CACHED_CWD)
                 # combine the difference between the cwd and the node path with the symlink path
-                return pathlib.Path(SYMLINK_PATH, rel_path)
+                result = pathlib.Path(SYMLINK_PATH, rel_path)
         except Exception as e:
             raise VSCodePytestError(
                 f"Error occurred while calculating symlink equivalent from node path: {e}"
-                f"\n SYMLINK_PATH: {SYMLINK_PATH}, \n node path: {node_path}, \n cwd: {pathlib.Path.cwd()}"
+                f"\n SYMLINK_PATH: {SYMLINK_PATH}, \n node path: {node_path}, \n cwd: {_CACHED_CWD or pathlib.Path.cwd()}"
             ) from e
-    return node_path
+    else:
+        result = node_path
+
+    # Cache before returning
+    _path_cache[cache_key] = result
+    return result
 
 
 __writer = None
diff --git a/python_files/vscode_pytest/run_pytest_script.py b/python_files/vscode_pytest/run_pytest_script.py
index 1abfb8b27004..50ab12a35423 100644
--- a/python_files/vscode_pytest/run_pytest_script.py
+++ b/python_files/vscode_pytest/run_pytest_script.py
@@ -47,24 +47,27 @@ def run_pytest(args):
                 coverage_enabled = True
                 break
         if not coverage_enabled:
-            args = [*args, "--cov=."]
+            args = [*args, "--cov=.", "--cov-branch"]
 
     run_test_ids_pipe = os.environ.get("RUN_TEST_IDS_PIPE")
     if run_test_ids_pipe:
+        ids_path = pathlib.Path(run_test_ids_pipe)
         try:
-            # Read the test ids from the file, delete file, and run pytest.
-            ids_path = pathlib.Path(run_test_ids_pipe)
+            # Read the test ids from the file and run pytest.
             ids = ids_path.read_text(encoding="utf-8").splitlines()
+        except Exception as e:
+            print("Error[vscode-pytest]: unable to read testIds from temp file" + str(e))
+            run_pytest(args)
+        else:
+            arg_array = ["-p", "vscode_pytest", *args, *ids]
+            print("Running pytest with args: " + str(arg_array))
+            pytest.main(arg_array)
+        finally:
+            # Delete the test ids temp file.
             try:
                 ids_path.unlink()
             except Exception as e:
                 print("Error[vscode-pytest]: unable to delete temp file" + str(e))
-            arg_array = ["-p", "vscode_pytest", *args, *ids]
-            print("Running pytest with args: " + str(arg_array))
-            pytest.main(arg_array)
-        except Exception as e:
-            print("Error[vscode-pytest]: unable to read testIds from temp file" + str(e))
-            run_pytest(args)
     else:
         print("Error[vscode-pytest]: RUN_TEST_IDS_PIPE env var is not set.")
         run_pytest(args)
diff --git a/requirements.in b/requirements.in
index d0e553cb9a5b..8bbc9a0f3728 100644
--- a/requirements.in
+++ b/requirements.in
@@ -1,10 +1,10 @@
 # This file is used to generate requirements.txt.
 # To update requirements.txt, run the following commands.
 # 1) Install `uv` https://docs.astral.sh/uv/getting-started/installation/
-# 2) uv pip compile --generate-hashes --upgrade requirements.in > requirements.txt
+# 2) uv pip compile --generate-hashes --upgrade requirements.in -o requirements.txt
 
 # Unittest test adapter
-typing-extensions==4.12.2
+typing-extensions==4.15.0
 
 # Fallback env creator for debian
 microvenv
diff --git a/requirements.txt b/requirements.txt
index 464d3abb1315..540590ed2ae7 100644
Binary files a/requirements.txt and b/requirements.txt differ
diff --git a/schemas/condarc.json b/schemas/condarc.json
index 396236238c1a..a881315d3137 100644
--- a/schemas/condarc.json
+++ b/schemas/condarc.json
@@ -59,7 +59,14 @@
             }
         },
         "ssl_verify": {
-            "type": "boolean"
+            "oneOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "string"
+                }
+            ]
         },
         "offline": {
             "type": "boolean"
diff --git a/src/client/activation/extensionSurvey.ts b/src/client/activation/extensionSurvey.ts
index e8df4bb850da..d32ba7180c0f 100644
--- a/src/client/activation/extensionSurvey.ts
+++ b/src/client/activation/extensionSurvey.ts
@@ -59,14 +59,14 @@ export class ExtensionSurveyPrompt implements IExtensionSingleActivationService
             return false;
         }
 
-        let feedbackDisabled = false;
+        let feedbackEnabled = true;
 
         const telemetryConfig = this.workspace.getConfiguration('telemetry');
         if (telemetryConfig) {
-            feedbackDisabled = telemetryConfig.get<boolean>('disableFeedback', false);
+            feedbackEnabled = telemetryConfig.get<boolean>('feedback.enabled', true);
         }
 
-        if (feedbackDisabled) {
+        if (!feedbackEnabled) {
             return false;
         }
 
diff --git a/src/client/activation/jedi/analysisOptions.ts b/src/client/activation/jedi/analysisOptions.ts
index 3b1897b91088..007008dc9b13 100644
--- a/src/client/activation/jedi/analysisOptions.ts
+++ b/src/client/activation/jedi/analysisOptions.ts
@@ -85,6 +85,9 @@ export class JediLanguageServerAnalysisOptions extends LanguageServerAnalysisOpt
                     maxSymbols: 0,
                 },
             },
+            semantic_tokens: {
+                enable: true,
+            },
         };
     }
 }
diff --git a/src/client/api.ts b/src/client/api.ts
index 15fb4d688a89..908da4be7103 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -45,8 +45,10 @@ export function buildApi(
         TensorboardExtensionIntegration,
         TensorboardExtensionIntegration,
     );
-    const jupyterIntegration = serviceContainer.get<JupyterExtensionIntegration>(JupyterExtensionIntegration);
     const jupyterPythonEnvApi = serviceContainer.get<JupyterPythonEnvironmentApi>(JupyterExtensionPythonEnvironments);
+    const environments = buildEnvironmentApi(discoveryApi, serviceContainer, jupyterPythonEnvApi);
+    const jupyterIntegration = serviceContainer.get<JupyterExtensionIntegration>(JupyterExtensionIntegration);
+    jupyterIntegration.registerEnvApi(environments);
     const tensorboardIntegration = serviceContainer.get<TensorboardExtensionIntegration>(
         TensorboardExtensionIntegration,
     );
@@ -155,7 +157,7 @@ export function buildApi(
             stop: (client: BaseLanguageClient): Promise<void> => client.stop(),
             getTelemetryReporter: () => getTelemetryReporter(),
         },
-        environments: buildEnvironmentApi(discoveryApi, serviceContainer, jupyterPythonEnvApi),
+        environments,
     };
 
     // In test environment return the DI Container.
diff --git a/src/client/application/diagnostics/checks/pythonInterpreter.ts b/src/client/application/diagnostics/checks/pythonInterpreter.ts
index 31da53e75357..9167e232a417 100644
--- a/src/client/application/diagnostics/checks/pythonInterpreter.ts
+++ b/src/client/application/diagnostics/checks/pythonInterpreter.ts
@@ -20,7 +20,7 @@ import {
     IDiagnosticHandlerService,
     IDiagnosticMessageOnCloseHandler,
 } from '../types';
-import { Common } from '../../../common/utils/localize';
+import { Common, Interpreters } from '../../../common/utils/localize';
 import { Commands } from '../../../common/constants';
 import { ICommandManager, IWorkspaceService } from '../../../common/application/types';
 import { sendTelemetryEvent } from '../../../telemetry';
@@ -30,11 +30,12 @@ import { cache } from '../../../common/utils/decorators';
 import { noop } from '../../../common/utils/misc';
 import { getEnvironmentVariable, getOSType, OSType } from '../../../common/utils/platform';
 import { IFileSystem } from '../../../common/platform/types';
-import { traceError } from '../../../logging';
+import { traceError, traceWarn } from '../../../logging';
 import { getExecutable } from '../../../common/process/internal/python';
 import { getSearchPathEnvVarNames } from '../../../common/utils/exec';
 import { IProcessServiceFactory } from '../../../common/process/types';
 import { normCasePath } from '../../../common/platform/fs-paths';
+import { useEnvExtension } from '../../../envExt/api.internal';
 
 const messages = {
     [DiagnosticCodes.NoPythonInterpretersDiagnostic]: l10n.t(
@@ -144,6 +145,9 @@ export class InvalidPythonInterpreterService extends BaseDiagnosticsService
         const isInterpreterSetToDefault = interpreterPathService.get(resource) === 'python';
 
         if (!hasInterpreters && isInterpreterSetToDefault) {
+            if (useEnvExtension()) {
+                traceWarn(Interpreters.envExtDiscoveryNoEnvironments);
+            }
             return [
                 new InvalidPythonInterpreterDiagnostic(
                     DiagnosticCodes.NoPythonInterpretersDiagnostic,
@@ -156,6 +160,9 @@ export class InvalidPythonInterpreterService extends BaseDiagnosticsService
 
         const currentInterpreter = await interpreterService.getActiveInterpreter(resource);
         if (!currentInterpreter) {
+            if (useEnvExtension()) {
+                traceWarn(Interpreters.envExtNoActiveEnvironment);
+            }
             return [
                 new InvalidPythonInterpreterDiagnostic(
                     DiagnosticCodes.InvalidPythonInterpreterDiagnostic,
diff --git a/src/client/chat/baseTool.ts b/src/client/chat/baseTool.ts
new file mode 100644
index 000000000000..d8e2e1d60d42
--- /dev/null
+++ b/src/client/chat/baseTool.ts
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+    workspace,
+} from 'vscode';
+import { IResourceReference, isCancellationError, resolveFilePath } from './utils';
+import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
+import { sendTelemetryEvent } from '../telemetry';
+import { EventName } from '../telemetry/constants';
+import { StopWatch } from '../common/utils/stopWatch';
+
+export abstract class BaseTool<T extends IResourceReference> implements LanguageModelTool<T> {
+    protected extraTelemetryProperties: Record<string, string> = {};
+    constructor(private readonly toolName: string) {}
+
+    async invoke(
+        options: LanguageModelToolInvocationOptions<T>,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        if (!workspace.isTrusted) {
+            return new LanguageModelToolResult([
+                new LanguageModelTextPart('Cannot use this tool in an untrusted workspace.'),
+            ]);
+        }
+        this.extraTelemetryProperties = {};
+        let error: Error | undefined;
+        const resource = resolveFilePath(options.input.resourcePath);
+        const stopWatch = new StopWatch();
+        try {
+            return await this.invokeImpl(options, resource, token);
+        } catch (ex) {
+            error = ex as any;
+            throw ex;
+        } finally {
+            const isCancelled = token.isCancellationRequested || (error ? isCancellationError(error) : false);
+            const failed = !!error || isCancelled;
+            const failureCategory = isCancelled
+                ? 'cancelled'
+                : error
+                ? error instanceof ErrorWithTelemetrySafeReason
+                    ? error.telemetrySafeReason
+                    : 'error'
+                : undefined;
+            sendTelemetryEvent(EventName.INVOKE_TOOL, stopWatch.elapsedTime, {
+                toolName: this.toolName,
+                failed,
+                failureCategory,
+                ...this.extraTelemetryProperties,
+            });
+        }
+    }
+    protected abstract invokeImpl(
+        options: LanguageModelToolInvocationOptions<T>,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult>;
+
+    async prepareInvocation(
+        options: LanguageModelToolInvocationPrepareOptions<T>,
+        token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        const resource = resolveFilePath(options.input.resourcePath);
+        return this.prepareInvocationImpl(options, resource, token);
+    }
+
+    protected abstract prepareInvocationImpl(
+        options: LanguageModelToolInvocationPrepareOptions<T>,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<PreparedToolInvocation>;
+}
diff --git a/src/client/chat/configurePythonEnvTool.ts b/src/client/chat/configurePythonEnvTool.ts
new file mode 100644
index 000000000000..914a92f81c52
--- /dev/null
+++ b/src/client/chat/configurePythonEnvTool.ts
@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+    workspace,
+    lm,
+} from 'vscode';
+import { PythonExtension } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import { ICodeExecutionService } from '../terminals/types';
+import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
+import {
+    getEnvDetailsForResponse,
+    getEnvTypeForTelemetry,
+    getToolResponseIfNotebook,
+    IResourceReference,
+    isCancellationError,
+    raceCancellationError,
+} from './utils';
+import { ITerminalHelper } from '../common/terminal/types';
+import { IRecommendedEnvironmentService } from '../interpreter/configuration/types';
+import { CreateVirtualEnvTool } from './createVirtualEnvTool';
+import { ISelectPythonEnvToolArguments, SelectPythonEnvTool } from './selectEnvTool';
+import { BaseTool } from './baseTool';
+
+export class ConfigurePythonEnvTool extends BaseTool<IResourceReference>
+    implements LanguageModelTool<IResourceReference> {
+    private readonly terminalExecutionService: TerminalCodeExecutionProvider;
+    private readonly terminalHelper: ITerminalHelper;
+    private readonly recommendedEnvService: IRecommendedEnvironmentService;
+    public static readonly toolName = 'configure_python_environment';
+    constructor(
+        private readonly api: PythonExtension['environments'],
+        private readonly serviceContainer: IServiceContainer,
+        private readonly createEnvTool: CreateVirtualEnvTool,
+    ) {
+        super(ConfigurePythonEnvTool.toolName);
+        this.terminalExecutionService = this.serviceContainer.get<TerminalCodeExecutionProvider>(
+            ICodeExecutionService,
+            'standard',
+        );
+        this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
+        this.recommendedEnvService = this.serviceContainer.get<IRecommendedEnvironmentService>(
+            IRecommendedEnvironmentService,
+        );
+    }
+
+    async invokeImpl(
+        options: LanguageModelToolInvocationOptions<IResourceReference>,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        const notebookResponse = getToolResponseIfNotebook(resource);
+        if (notebookResponse) {
+            this.extraTelemetryProperties.resolveOutcome = 'notebook';
+            return notebookResponse;
+        }
+
+        const workspaceSpecificEnv = await raceCancellationError(
+            this.hasAlreadyGotAWorkspaceSpecificEnvironment(resource),
+            token,
+        );
+
+        if (workspaceSpecificEnv) {
+            this.extraTelemetryProperties.resolveOutcome = 'existingWorkspaceEnv';
+            this.extraTelemetryProperties.envType = getEnvTypeForTelemetry(workspaceSpecificEnv);
+            return getEnvDetailsForResponse(
+                workspaceSpecificEnv,
+                this.api,
+                this.terminalExecutionService,
+                this.terminalHelper,
+                resource,
+                token,
+            );
+        }
+
+        if (await this.createEnvTool.shouldCreateNewVirtualEnv(resource, token)) {
+            try {
+                const result = await lm.invokeTool(CreateVirtualEnvTool.toolName, options, token);
+                this.extraTelemetryProperties.resolveOutcome = 'createdVirtualEnv';
+                return result;
+            } catch (ex) {
+                if (isCancellationError(ex)) {
+                    const input: ISelectPythonEnvToolArguments = {
+                        ...options.input,
+                        reason: 'cancelled',
+                    };
+                    // If the user cancelled the tool, then we should invoke the select env tool.
+                    this.extraTelemetryProperties.resolveOutcome = 'selectedEnvAfterCancelledCreate';
+                    return lm.invokeTool(SelectPythonEnvTool.toolName, { ...options, input }, token);
+                }
+                throw ex;
+            }
+        } else {
+            const input: ISelectPythonEnvToolArguments = {
+                ...options.input,
+            };
+            this.extraTelemetryProperties.resolveOutcome = 'selectedEnv';
+            return lm.invokeTool(SelectPythonEnvTool.toolName, { ...options, input }, token);
+        }
+    }
+
+    async prepareInvocationImpl(
+        _options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        _resource: Uri | undefined,
+        _token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        return {
+            invocationMessage: 'Configuring a Python Environment',
+        };
+    }
+
+    async hasAlreadyGotAWorkspaceSpecificEnvironment(resource: Uri | undefined) {
+        const recommededEnv = await this.recommendedEnvService.getRecommededEnvironment(resource);
+        // Already selected workspace env, hence nothing to do.
+        if (recommededEnv?.reason === 'workspaceUserSelected' && workspace.workspaceFolders?.length) {
+            return recommededEnv.environment;
+        }
+        // No workspace folders, and the user selected a global environment.
+        if (recommededEnv?.reason === 'globalUserSelected' && !workspace.workspaceFolders?.length) {
+            return recommededEnv.environment;
+        }
+    }
+}
diff --git a/src/client/chat/createVirtualEnvTool.ts b/src/client/chat/createVirtualEnvTool.ts
new file mode 100644
index 000000000000..56760d2b4bef
--- /dev/null
+++ b/src/client/chat/createVirtualEnvTool.ts
@@ -0,0 +1,246 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationError,
+    CancellationToken,
+    commands,
+    l10n,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+    workspace,
+} from 'vscode';
+import { PythonExtension, ResolvedEnvironment } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import { ICodeExecutionService } from '../terminals/types';
+import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
+import {
+    doesWorkspaceHaveVenvOrCondaEnv,
+    getDisplayVersion,
+    getEnvDetailsForResponse,
+    IResourceReference,
+    isCancellationError,
+    raceCancellationError,
+} from './utils';
+import { ITerminalHelper } from '../common/terminal/types';
+import { raceTimeout, sleep } from '../common/utils/async';
+import { IInterpreterPathService } from '../common/types';
+import { DisposableStore } from '../common/utils/resourceLifecycle';
+import { IRecommendedEnvironmentService } from '../interpreter/configuration/types';
+import { EnvironmentType } from '../pythonEnvironments/info';
+import { IDiscoveryAPI } from '../pythonEnvironments/base/locator';
+import { convertEnvInfoToPythonEnvironment } from '../pythonEnvironments/legacyIOC';
+import { sortInterpreters } from '../interpreter/helpers';
+import { isStableVersion } from '../pythonEnvironments/info/pythonVersion';
+import { createVirtualEnvironment } from '../pythonEnvironments/creation/createEnvApi';
+import { traceError, traceVerbose, traceWarn } from '../logging';
+import { StopWatch } from '../common/utils/stopWatch';
+import { useEnvExtension } from '../envExt/api.internal';
+import { PythonEnvironment } from '../envExt/types';
+import { hideEnvCreation } from '../pythonEnvironments/creation/provider/hideEnvCreation';
+import { BaseTool } from './baseTool';
+
+interface ICreateVirtualEnvToolParams extends IResourceReference {
+    packageList?: string[]; // Added only becausewe have ability to create a virtual env with list of packages same tool within the in Python Env extension.
+}
+
+export class CreateVirtualEnvTool extends BaseTool<ICreateVirtualEnvToolParams>
+    implements LanguageModelTool<ICreateVirtualEnvToolParams> {
+    private readonly terminalExecutionService: TerminalCodeExecutionProvider;
+    private readonly terminalHelper: ITerminalHelper;
+    private readonly recommendedEnvService: IRecommendedEnvironmentService;
+
+    public static readonly toolName = 'create_virtual_environment';
+    constructor(
+        private readonly discoveryApi: IDiscoveryAPI,
+        private readonly api: PythonExtension['environments'],
+        private readonly serviceContainer: IServiceContainer,
+    ) {
+        super(CreateVirtualEnvTool.toolName);
+        this.terminalExecutionService = this.serviceContainer.get<TerminalCodeExecutionProvider>(
+            ICodeExecutionService,
+            'standard',
+        );
+        this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
+        this.recommendedEnvService = this.serviceContainer.get<IRecommendedEnvironmentService>(
+            IRecommendedEnvironmentService,
+        );
+    }
+
+    async invokeImpl(
+        options: LanguageModelToolInvocationOptions<ICreateVirtualEnvToolParams>,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        let info = await this.getPreferredEnvForCreation(resource);
+        if (!info) {
+            traceWarn(`Called ${CreateVirtualEnvTool.toolName} tool not invoked, no preferred environment found.`);
+            throw new CancellationError();
+        }
+        const { workspaceFolder, preferredGlobalPythonEnv } = info;
+        const interpreterPathService = this.serviceContainer.get<IInterpreterPathService>(IInterpreterPathService);
+        const disposables = new DisposableStore();
+        try {
+            disposables.add(hideEnvCreation());
+            const interpreterChanged = new Promise<void>((resolve) => {
+                disposables.add(interpreterPathService.onDidChange(() => resolve()));
+            });
+
+            let createdEnvPath: string | undefined = undefined;
+            if (useEnvExtension()) {
+                const result: PythonEnvironment | undefined = await commands.executeCommand('python-envs.createAny', {
+                    quickCreate: true,
+                    additionalPackages: options.input.packageList || [],
+                    uri: workspaceFolder.uri,
+                    selectEnvironment: true,
+                });
+                createdEnvPath = result?.environmentPath.fsPath;
+            } else {
+                const created = await raceCancellationError(
+                    createVirtualEnvironment({
+                        interpreter: preferredGlobalPythonEnv.id,
+                        workspaceFolder,
+                    }),
+                    token,
+                );
+                createdEnvPath = created?.path;
+            }
+            if (!createdEnvPath) {
+                traceWarn(`${CreateVirtualEnvTool.toolName} tool not invoked, virtual env not created.`);
+                throw new CancellationError();
+            }
+
+            // Wait a few secs to ensure the env is selected as the active environment..
+            // If this doesn't work, then something went wrong.
+            await raceTimeout(5_000, interpreterChanged);
+
+            const stopWatch = new StopWatch();
+            let env: ResolvedEnvironment | undefined;
+            while (stopWatch.elapsedTime < 5_000 || !env) {
+                env = await this.api.resolveEnvironment(createdEnvPath);
+                if (env) {
+                    break;
+                } else {
+                    traceVerbose(
+                        `${CreateVirtualEnvTool.toolName} tool invoked, env created but not yet resolved, waiting...`,
+                    );
+                    await sleep(200);
+                }
+            }
+            if (!env) {
+                traceError(`${CreateVirtualEnvTool.toolName} tool invoked, env created but unable to resolve details.`);
+                throw new CancellationError();
+            }
+            return await getEnvDetailsForResponse(
+                env,
+                this.api,
+                this.terminalExecutionService,
+                this.terminalHelper,
+                resource,
+                token,
+            );
+        } catch (ex) {
+            if (!isCancellationError(ex)) {
+                traceError(
+                    `${
+                        CreateVirtualEnvTool.toolName
+                    } tool failed to create virtual environment for resource ${resource?.toString()}`,
+                    ex,
+                );
+            }
+            throw ex;
+        } finally {
+            disposables.dispose();
+        }
+    }
+
+    public async shouldCreateNewVirtualEnv(resource: Uri | undefined, token: CancellationToken): Promise<boolean> {
+        if (doesWorkspaceHaveVenvOrCondaEnv(resource, this.api)) {
+            // If we already have a .venv or .conda in this workspace, then do not prompt to create a virtual environment.
+            return false;
+        }
+
+        const info = await raceCancellationError(this.getPreferredEnvForCreation(resource), token);
+        return info ? true : false;
+    }
+
+    async prepareInvocationImpl(
+        _options: LanguageModelToolInvocationPrepareOptions<ICreateVirtualEnvToolParams>,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        const info = await raceCancellationError(this.getPreferredEnvForCreation(resource), token);
+        if (!info) {
+            return {};
+        }
+        const { preferredGlobalPythonEnv } = info;
+        const version = getDisplayVersion(preferredGlobalPythonEnv.version);
+        return {
+            confirmationMessages: {
+                title: l10n.t('Create a Virtual Environment{0}?', version ? ` (${version})` : ''),
+                message: l10n.t(`Virtual Environments provide the benefit of package isolation and more.`),
+            },
+            invocationMessage: l10n.t('Creating a Virtual Environment'),
+        };
+    }
+    async hasAlreadyGotAWorkspaceSpecificEnvironment(resource: Uri | undefined) {
+        const recommededEnv = await this.recommendedEnvService.getRecommededEnvironment(resource);
+        // Already selected workspace env, hence nothing to do.
+        if (recommededEnv?.reason === 'workspaceUserSelected' && workspace.workspaceFolders?.length) {
+            return recommededEnv.environment;
+        }
+        // No workspace folders, and the user selected a global environment.
+        if (recommededEnv?.reason === 'globalUserSelected' && !workspace.workspaceFolders?.length) {
+            return recommededEnv.environment;
+        }
+    }
+
+    private async getPreferredEnvForCreation(resource: Uri | undefined) {
+        if (await this.hasAlreadyGotAWorkspaceSpecificEnvironment(resource)) {
+            return undefined;
+        }
+
+        // If we have a resource or have only one workspace folder && there is no .venv and no workspace specific environment.
+        // Then lets recommend creating a virtual environment.
+        const workspaceFolder =
+            resource && workspace.workspaceFolders?.length
+                ? workspace.getWorkspaceFolder(resource)
+                : workspace.workspaceFolders?.length === 1
+                ? workspace.workspaceFolders[0]
+                : undefined;
+        if (!workspaceFolder) {
+            // No workspace folder, hence no need to create a virtual environment.
+            return undefined;
+        }
+
+        // Find the latest stable version of Python from the list of know envs.
+        let globalPythonEnvs = this.discoveryApi
+            .getEnvs()
+            .map((env) => convertEnvInfoToPythonEnvironment(env))
+            .filter((env) =>
+                [
+                    EnvironmentType.System,
+                    EnvironmentType.MicrosoftStore,
+                    EnvironmentType.Global,
+                    EnvironmentType.Pyenv,
+                ].includes(env.envType),
+            )
+            .filter((env) => env.version && isStableVersion(env.version));
+
+        globalPythonEnvs = sortInterpreters(globalPythonEnvs);
+        const preferredGlobalPythonEnv = globalPythonEnvs.length
+            ? this.api.known.find((e) => e.id === globalPythonEnvs[globalPythonEnvs.length - 1].id)
+            : undefined;
+
+        return workspaceFolder && preferredGlobalPythonEnv
+            ? {
+                  workspaceFolder,
+                  preferredGlobalPythonEnv,
+              }
+            : undefined;
+    }
+}
diff --git a/src/client/chat/getExecutableTool.ts b/src/client/chat/getExecutableTool.ts
new file mode 100644
index 000000000000..38dabce644a7
--- /dev/null
+++ b/src/client/chat/getExecutableTool.ts
@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    l10n,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+} from 'vscode';
+import { PythonExtension } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import { ICodeExecutionService } from '../terminals/types';
+import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
+import {
+    getEnvDisplayName,
+    getEnvironmentDetails,
+    getEnvTypeForTelemetry,
+    getToolResponseIfNotebook,
+    IResourceReference,
+    raceCancellationError,
+} from './utils';
+import { ITerminalHelper } from '../common/terminal/types';
+import { IDiscoveryAPI } from '../pythonEnvironments/base/locator';
+import { BaseTool } from './baseTool';
+
+export class GetExecutableTool extends BaseTool<IResourceReference> implements LanguageModelTool<IResourceReference> {
+    private readonly terminalExecutionService: TerminalCodeExecutionProvider;
+    private readonly terminalHelper: ITerminalHelper;
+    public static readonly toolName = 'get_python_executable_details';
+    constructor(
+        private readonly api: PythonExtension['environments'],
+        private readonly serviceContainer: IServiceContainer,
+        private readonly discovery: IDiscoveryAPI,
+    ) {
+        super(GetExecutableTool.toolName);
+        this.terminalExecutionService = this.serviceContainer.get<TerminalCodeExecutionProvider>(
+            ICodeExecutionService,
+            'standard',
+        );
+        this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
+    }
+    async invokeImpl(
+        _options: LanguageModelToolInvocationOptions<IResourceReference>,
+        resourcePath: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        const notebookResponse = getToolResponseIfNotebook(resourcePath);
+        if (notebookResponse) {
+            return notebookResponse;
+        }
+
+        const envPath = this.api.getActiveEnvironmentPath(resourcePath);
+        const environment = await raceCancellationError(this.api.resolveEnvironment(envPath), token);
+        if (environment) {
+            this.extraTelemetryProperties.envType = getEnvTypeForTelemetry(environment);
+        }
+
+        const message = await getEnvironmentDetails(
+            resourcePath,
+            this.api,
+            this.terminalExecutionService,
+            this.terminalHelper,
+            undefined,
+            token,
+        );
+        return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
+    }
+
+    async prepareInvocationImpl(
+        _options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        resourcePath: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        if (getToolResponseIfNotebook(resourcePath)) {
+            return {};
+        }
+
+        const envName = await raceCancellationError(getEnvDisplayName(this.discovery, resourcePath, this.api), token);
+        return {
+            invocationMessage: envName
+                ? l10n.t('Fetching Python executable information for {0}', envName)
+                : l10n.t('Fetching Python executable information'),
+        };
+    }
+}
diff --git a/src/client/chat/getPythonEnvTool.ts b/src/client/chat/getPythonEnvTool.ts
new file mode 100644
index 000000000000..d25d72baeba8
--- /dev/null
+++ b/src/client/chat/getPythonEnvTool.ts
@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    l10n,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+} from 'vscode';
+import { PythonExtension } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import { ICodeExecutionService } from '../terminals/types';
+import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
+import { IProcessServiceFactory, IPythonExecutionFactory } from '../common/process/types';
+import {
+    getEnvironmentDetails,
+    getEnvTypeForTelemetry,
+    getToolResponseIfNotebook,
+    IResourceReference,
+    raceCancellationError,
+} from './utils';
+import { getPythonPackagesResponse } from './listPackagesTool';
+import { ITerminalHelper } from '../common/terminal/types';
+import { getEnvExtApi, useEnvExtension } from '../envExt/api.internal';
+import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
+import { BaseTool } from './baseTool';
+
+export class GetEnvironmentInfoTool extends BaseTool<IResourceReference>
+    implements LanguageModelTool<IResourceReference> {
+    private readonly terminalExecutionService: TerminalCodeExecutionProvider;
+    private readonly pythonExecFactory: IPythonExecutionFactory;
+    private readonly processServiceFactory: IProcessServiceFactory;
+    private readonly terminalHelper: ITerminalHelper;
+    public static readonly toolName = 'get_python_environment_details';
+    constructor(
+        private readonly api: PythonExtension['environments'],
+        private readonly serviceContainer: IServiceContainer,
+    ) {
+        super(GetEnvironmentInfoTool.toolName);
+        this.terminalExecutionService = this.serviceContainer.get<TerminalCodeExecutionProvider>(
+            ICodeExecutionService,
+            'standard',
+        );
+        this.pythonExecFactory = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
+        this.processServiceFactory = this.serviceContainer.get<IProcessServiceFactory>(IProcessServiceFactory);
+        this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
+    }
+
+    async invokeImpl(
+        _options: LanguageModelToolInvocationOptions<IResourceReference>,
+        resourcePath: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        const notebookResponse = getToolResponseIfNotebook(resourcePath);
+        if (notebookResponse) {
+            return notebookResponse;
+        }
+
+        // environment
+        const envPath = this.api.getActiveEnvironmentPath(resourcePath);
+        const environment = await raceCancellationError(this.api.resolveEnvironment(envPath), token);
+        if (!environment || !environment.version) {
+            throw new ErrorWithTelemetrySafeReason(
+                'No environment found for the provided resource path: ' + resourcePath?.fsPath,
+                'noEnvFound',
+            );
+        }
+        this.extraTelemetryProperties.envType = getEnvTypeForTelemetry(environment);
+
+        let packages = '';
+        let responsePackageCount = 0;
+        if (useEnvExtension()) {
+            const api = await getEnvExtApi();
+            const env = await api.getEnvironment(resourcePath);
+            const pkgs = env ? await api.getPackages(env) : [];
+            if (pkgs && pkgs.length > 0) {
+                responsePackageCount = pkgs.length;
+                // Installed Python packages, each in the format <name> or <name> (<version>). The version may be omitted if unknown. Returns an empty array if no packages are installed.
+                const response = [
+                    'Below is a list of the Python packages, each in the format <name> or <name> (<version>). The version may be omitted if unknown: ',
+                ];
+                pkgs.forEach((pkg) => {
+                    const version = pkg.version;
+                    response.push(version ? `- ${pkg.name} (${version})` : `- ${pkg.name}`);
+                });
+                packages = response.join('\n');
+            }
+        }
+        if (!packages) {
+            packages = await getPythonPackagesResponse(
+                environment,
+                this.pythonExecFactory,
+                this.processServiceFactory,
+                resourcePath,
+                token,
+            );
+            // Count lines starting with '- ' to get the number of packages
+            responsePackageCount = (packages.match(/^- /gm) || []).length;
+        }
+        this.extraTelemetryProperties.responsePackageCount = String(responsePackageCount);
+        const message = await getEnvironmentDetails(
+            resourcePath,
+            this.api,
+            this.terminalExecutionService,
+            this.terminalHelper,
+            packages,
+            token,
+        );
+
+        return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
+    }
+
+    async prepareInvocationImpl(
+        _options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        resourcePath: Uri | undefined,
+        _token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        if (getToolResponseIfNotebook(resourcePath)) {
+            return {};
+        }
+
+        return {
+            invocationMessage: l10n.t('Fetching Python environment information'),
+        };
+    }
+}
diff --git a/src/client/chat/index.ts b/src/client/chat/index.ts
new file mode 100644
index 000000000000..b548860eaae3
--- /dev/null
+++ b/src/client/chat/index.ts
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { lm } from 'vscode';
+import { PythonExtension } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import { InstallPackagesTool } from './installPackagesTool';
+import { IExtensionContext } from '../common/types';
+import { DisposableStore } from '../common/utils/resourceLifecycle';
+import { IDiscoveryAPI } from '../pythonEnvironments/base/locator';
+import { GetExecutableTool } from './getExecutableTool';
+import { GetEnvironmentInfoTool } from './getPythonEnvTool';
+import { ConfigurePythonEnvTool } from './configurePythonEnvTool';
+import { SelectPythonEnvTool } from './selectEnvTool';
+import { CreateVirtualEnvTool } from './createVirtualEnvTool';
+
+export function registerTools(
+    context: IExtensionContext,
+    discoverApi: IDiscoveryAPI,
+    environmentsApi: PythonExtension['environments'],
+    serviceContainer: IServiceContainer,
+) {
+    const ourTools = new DisposableStore();
+    context.subscriptions.push(ourTools);
+
+    ourTools.add(
+        lm.registerTool(GetEnvironmentInfoTool.toolName, new GetEnvironmentInfoTool(environmentsApi, serviceContainer)),
+    );
+    ourTools.add(
+        lm.registerTool(
+            GetExecutableTool.toolName,
+            new GetExecutableTool(environmentsApi, serviceContainer, discoverApi),
+        ),
+    );
+    ourTools.add(
+        lm.registerTool(
+            InstallPackagesTool.toolName,
+            new InstallPackagesTool(environmentsApi, serviceContainer, discoverApi),
+        ),
+    );
+    const createVirtualEnvTool = new CreateVirtualEnvTool(discoverApi, environmentsApi, serviceContainer);
+    ourTools.add(lm.registerTool(CreateVirtualEnvTool.toolName, createVirtualEnvTool));
+    ourTools.add(
+        lm.registerTool(SelectPythonEnvTool.toolName, new SelectPythonEnvTool(environmentsApi, serviceContainer)),
+    );
+    ourTools.add(
+        lm.registerTool(
+            ConfigurePythonEnvTool.toolName,
+            new ConfigurePythonEnvTool(environmentsApi, serviceContainer, createVirtualEnvTool),
+        ),
+    );
+}
diff --git a/src/client/chat/installPackagesTool.ts b/src/client/chat/installPackagesTool.ts
new file mode 100644
index 000000000000..5d3d456361f9
--- /dev/null
+++ b/src/client/chat/installPackagesTool.ts
@@ -0,0 +1,167 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    l10n,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+} from 'vscode';
+import { PythonExtension } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import {
+    getEnvDisplayName,
+    getEnvTypeForTelemetry,
+    getToolResponseIfNotebook,
+    IResourceReference,
+    isCancellationError,
+    isCondaEnv,
+    raceCancellationError,
+} from './utils';
+import { IModuleInstaller } from '../common/installer/types';
+import { ModuleInstallerType } from '../pythonEnvironments/info';
+import { IDiscoveryAPI } from '../pythonEnvironments/base/locator';
+import { getEnvExtApi, useEnvExtension } from '../envExt/api.internal';
+import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
+import { BaseTool } from './baseTool';
+
+export interface IInstallPackageArgs extends IResourceReference {
+    packageList: string[];
+}
+
+export class InstallPackagesTool extends BaseTool<IInstallPackageArgs>
+    implements LanguageModelTool<IInstallPackageArgs> {
+    public static readonly toolName = 'install_python_packages';
+    constructor(
+        private readonly api: PythonExtension['environments'],
+        private readonly serviceContainer: IServiceContainer,
+        private readonly discovery: IDiscoveryAPI,
+    ) {
+        super(InstallPackagesTool.toolName);
+    }
+
+    async invokeImpl(
+        options: LanguageModelToolInvocationOptions<IInstallPackageArgs>,
+        resourcePath: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        const packageCount = options.input.packageList.length;
+        const packagePlurality = packageCount === 1 ? 'package' : 'packages';
+        this.extraTelemetryProperties.packageCount = String(packageCount);
+        const notebookResponse = getToolResponseIfNotebook(resourcePath);
+        if (notebookResponse) {
+            return notebookResponse;
+        }
+
+        if (useEnvExtension()) {
+            const api = await getEnvExtApi();
+            const env = await api.getEnvironment(resourcePath);
+            if (env) {
+                await raceCancellationError(api.managePackages(env, { install: options.input.packageList }), token);
+                const resultMessage = `Successfully installed ${packagePlurality}: ${options.input.packageList.join(
+                    ', ',
+                )}`;
+                return new LanguageModelToolResult([new LanguageModelTextPart(resultMessage)]);
+            } else {
+                return new LanguageModelToolResult([
+                    new LanguageModelTextPart(
+                        `Packages not installed. No environment found for: ${resourcePath?.fsPath}`,
+                    ),
+                ]);
+            }
+        }
+
+        try {
+            // environment
+            const envPath = this.api.getActiveEnvironmentPath(resourcePath);
+            const environment = await raceCancellationError(this.api.resolveEnvironment(envPath), token);
+            if (!environment || !environment.version) {
+                throw new ErrorWithTelemetrySafeReason(
+                    'No environment found for the provided resource path: ' + resourcePath?.fsPath,
+                    'noEnvFound',
+                );
+            }
+            this.extraTelemetryProperties.envType = getEnvTypeForTelemetry(environment);
+            const isConda = isCondaEnv(environment);
+            const installers = this.serviceContainer.getAll<IModuleInstaller>(IModuleInstaller);
+            const installerType = isConda ? ModuleInstallerType.Conda : ModuleInstallerType.Pip;
+            this.extraTelemetryProperties.installerType = isConda ? 'conda' : 'pip';
+            const installer = installers.find((i) => i.type === installerType);
+            if (!installer) {
+                throw new ErrorWithTelemetrySafeReason(
+                    `No installer found for the environment type: ${installerType}`,
+                    'noInstallerFound',
+                );
+            }
+            if (!installer.isSupported(resourcePath)) {
+                throw new ErrorWithTelemetrySafeReason(
+                    `Installer ${installerType} not supported for the environment type: ${installerType}`,
+                    'installerNotSupported',
+                );
+            }
+            for (const packageName of options.input.packageList) {
+                await installer.installModule(packageName, resourcePath, token, undefined, {
+                    installAsProcess: true,
+                    hideProgress: true,
+                });
+            }
+            // format and return
+            const resultMessage = `Successfully installed ${packagePlurality}: ${options.input.packageList.join(', ')}`;
+            return new LanguageModelToolResult([new LanguageModelTextPart(resultMessage)]);
+        } catch (error) {
+            if (isCancellationError(error)) {
+                throw error;
+            }
+            const errorMessage = `An error occurred while installing ${packagePlurality}: ${error}`;
+            return new LanguageModelToolResult([new LanguageModelTextPart(errorMessage)]);
+        }
+    }
+
+    async prepareInvocationImpl(
+        options: LanguageModelToolInvocationPrepareOptions<IInstallPackageArgs>,
+        resourcePath: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        const packageCount = options.input.packageList.length;
+        if (getToolResponseIfNotebook(resourcePath)) {
+            return {};
+        }
+
+        const envName = await raceCancellationError(getEnvDisplayName(this.discovery, resourcePath, this.api), token);
+        let title = '';
+        let invocationMessage = '';
+        const message =
+            packageCount === 1
+                ? ''
+                : l10n.t(`The following packages will be installed: {0}`, options.input.packageList.sort().join(', '));
+        if (envName) {
+            title =
+                packageCount === 1
+                    ? l10n.t(`Install {0} in {1}?`, options.input.packageList[0], envName)
+                    : l10n.t(`Install packages in {0}?`, envName);
+            invocationMessage =
+                packageCount === 1
+                    ? l10n.t(`Installing {0} in {1}`, options.input.packageList[0], envName)
+                    : l10n.t(`Installing packages {0} in {1}`, options.input.packageList.sort().join(', '), envName);
+        } else {
+            title =
+                options.input.packageList.length === 1
+                    ? l10n.t(`Install Python package '{0}'?`, options.input.packageList[0])
+                    : l10n.t(`Install Python packages?`);
+            invocationMessage =
+                packageCount === 1
+                    ? l10n.t(`Installing Python package '{0}'`, options.input.packageList[0])
+                    : l10n.t(`Installing Python packages: {0}`, options.input.packageList.sort().join(', '));
+        }
+
+        return {
+            confirmationMessages: { title, message },
+            invocationMessage,
+        };
+    }
+}
diff --git a/src/client/chat/listPackagesTool.ts b/src/client/chat/listPackagesTool.ts
new file mode 100644
index 000000000000..fcae831cfe2f
--- /dev/null
+++ b/src/client/chat/listPackagesTool.ts
@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { CancellationToken, Uri } from 'vscode';
+import { ResolvedEnvironment } from '../api/types';
+import { IProcessService, IProcessServiceFactory, IPythonExecutionFactory } from '../common/process/types';
+import { isCondaEnv, raceCancellationError } from './utils';
+import { parsePipList } from './pipListUtils';
+import { Conda } from '../pythonEnvironments/common/environmentManagers/conda';
+import { traceError } from '../logging';
+
+export async function getPythonPackagesResponse(
+    environment: ResolvedEnvironment,
+    pythonExecFactory: IPythonExecutionFactory,
+    processServiceFactory: IProcessServiceFactory,
+    resourcePath: Uri | undefined,
+    token: CancellationToken,
+): Promise<string> {
+    const packages = isCondaEnv(environment)
+        ? await raceCancellationError(
+              listCondaPackages(
+                  pythonExecFactory,
+                  environment,
+                  resourcePath,
+                  await raceCancellationError(processServiceFactory.create(resourcePath), token),
+              ),
+              token,
+          )
+        : await raceCancellationError(listPipPackages(pythonExecFactory, resourcePath), token);
+
+    if (!packages.length) {
+        return 'No packages found';
+    }
+    // Installed Python packages, each in the format <name> or <name> (<version>). The version may be omitted if unknown. Returns an empty array if no packages are installed.
+    const response = [
+        'Below is a list of the Python packages, each in the format <name> or <name> (<version>). The version may be omitted if unknown: ',
+    ];
+    packages.forEach((pkg) => {
+        const [name, version] = pkg;
+        response.push(version ? `- ${name} (${version})` : `- ${name}`);
+    });
+    return response.join('\n');
+}
+
+async function listPipPackages(
+    execFactory: IPythonExecutionFactory,
+    resource: Uri | undefined,
+): Promise<[string, string][]> {
+    // Add option --format to subcommand list of pip  cache, with abspath choice to output the full path of a wheel file. (#8355)
+    // Added in 2020. Thats almost 5 years ago. When Python 3.8 was released.
+    const exec = await execFactory.createActivatedEnvironment({ allowEnvironmentFetchExceptions: true, resource });
+    const output = await exec.execModule('pip', ['list'], { throwOnStdErr: false, encoding: 'utf8' });
+    return parsePipList(output.stdout).map((pkg) => [pkg.name, pkg.version]);
+}
+
+async function listCondaPackages(
+    execFactory: IPythonExecutionFactory,
+    env: ResolvedEnvironment,
+    resource: Uri | undefined,
+    processService: IProcessService,
+): Promise<[string, string][]> {
+    const conda = await Conda.getConda();
+    if (!conda) {
+        traceError('Conda is not installed, falling back to pip packages');
+        return listPipPackages(execFactory, resource);
+    }
+    if (!env.executable.uri) {
+        traceError('Conda environment executable not found, falling back to pip packages');
+        return listPipPackages(execFactory, resource);
+    }
+    const condaEnv = await conda.getCondaEnvironment(env.executable.uri.fsPath);
+    if (!condaEnv) {
+        traceError('Conda environment not found, falling back to pip packages');
+        return listPipPackages(execFactory, resource);
+    }
+    const cmd = await conda.getListPythonPackagesArgs(condaEnv, true);
+    if (!cmd) {
+        traceError('Conda list command not found, falling back to pip packages');
+        return listPipPackages(execFactory, resource);
+    }
+    const output = await processService.exec(cmd[0], cmd.slice(1), { shell: true });
+    if (!output.stdout) {
+        traceError('Unable to get conda packages, falling back to pip packages');
+        return listPipPackages(execFactory, resource);
+    }
+    const content = output.stdout.split(/\r?\n/).filter((l) => !l.startsWith('#'));
+    const packages: [string, string][] = [];
+    content.forEach((l) => {
+        const parts = l.split(' ').filter((p) => p.length > 0);
+        if (parts.length >= 3) {
+            packages.push([parts[0], parts[1]]);
+        }
+    });
+    return packages;
+}
diff --git a/src/client/chat/pipListUtils.ts b/src/client/chat/pipListUtils.ts
new file mode 100644
index 000000000000..0112d88c53ab
--- /dev/null
+++ b/src/client/chat/pipListUtils.ts
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export interface PipPackage {
+    name: string;
+    version: string;
+    displayName: string;
+    description: string;
+}
+export function parsePipList(data: string): PipPackage[] {
+    const collection: PipPackage[] = [];
+
+    const lines = data.split('\n').splice(2);
+    for (let line of lines) {
+        if (line.trim() === '' || line.startsWith('Package') || line.startsWith('----') || line.startsWith('[')) {
+            continue;
+        }
+        const parts = line.split(' ').filter((e) => e);
+        if (parts.length > 1) {
+            const name = parts[0].trim();
+            const version = parts[1].trim();
+            const pkg = {
+                name,
+                version,
+                displayName: name,
+                description: version,
+            };
+            collection.push(pkg);
+        }
+    }
+    return collection;
+}
diff --git a/src/client/chat/selectEnvTool.ts b/src/client/chat/selectEnvTool.ts
new file mode 100644
index 000000000000..9eeebdfc1b56
--- /dev/null
+++ b/src/client/chat/selectEnvTool.ts
@@ -0,0 +1,218 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    l10n,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+    Uri,
+    workspace,
+    commands,
+    QuickPickItem,
+    QuickPickItemKind,
+} from 'vscode';
+import { PythonExtension } from '../api/types';
+import { IServiceContainer } from '../ioc/types';
+import { ICodeExecutionService } from '../terminals/types';
+import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
+import {
+    doesWorkspaceHaveVenvOrCondaEnv,
+    getEnvDetailsForResponse,
+    getToolResponseIfNotebook,
+    IResourceReference,
+} from './utils';
+import { ITerminalHelper } from '../common/terminal/types';
+import { raceTimeout } from '../common/utils/async';
+import { Commands, Octicons } from '../common/constants';
+import { CreateEnvironmentResult } from '../pythonEnvironments/creation/proposed.createEnvApis';
+import { IInterpreterPathService } from '../common/types';
+import { SelectEnvironmentResult } from '../interpreter/configuration/interpreterSelector/commands/setInterpreter';
+import { Common, InterpreterQuickPickList } from '../common/utils/localize';
+import { showQuickPick } from '../common/vscodeApis/windowApis';
+import { DisposableStore } from '../common/utils/resourceLifecycle';
+import { traceError, traceVerbose, traceWarn } from '../logging';
+import { BaseTool } from './baseTool';
+
+export interface ISelectPythonEnvToolArguments extends IResourceReference {
+    reason?: 'cancelled';
+}
+
+export class SelectPythonEnvTool extends BaseTool<ISelectPythonEnvToolArguments>
+    implements LanguageModelTool<ISelectPythonEnvToolArguments> {
+    private readonly terminalExecutionService: TerminalCodeExecutionProvider;
+    private readonly terminalHelper: ITerminalHelper;
+    public static readonly toolName = 'selectEnvironment';
+    constructor(
+        private readonly api: PythonExtension['environments'],
+        private readonly serviceContainer: IServiceContainer,
+    ) {
+        super(SelectPythonEnvTool.toolName);
+        this.terminalExecutionService = this.serviceContainer.get<TerminalCodeExecutionProvider>(
+            ICodeExecutionService,
+            'standard',
+        );
+        this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
+    }
+
+    async invokeImpl(
+        options: LanguageModelToolInvocationOptions<ISelectPythonEnvToolArguments>,
+        resource: Uri | undefined,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        let selected: boolean | undefined = false;
+        const hasVenvOrCondaEnvInWorkspaceFolder = doesWorkspaceHaveVenvOrCondaEnv(resource, this.api);
+        if (options.input.reason === 'cancelled' || hasVenvOrCondaEnvInWorkspaceFolder) {
+            const result = (await Promise.resolve(
+                commands.executeCommand(Commands.Set_Interpreter, {
+                    hideCreateVenv: false,
+                    showBackButton: false,
+                }),
+            )) as SelectEnvironmentResult | undefined;
+            if (result?.path) {
+                traceVerbose(`User selected a Python environment ${result.path} in Select Python Tool.`);
+                selected = true;
+            } else {
+                traceWarn(`User did not select a Python environment in Select Python Tool.`);
+            }
+        } else {
+            selected = await showCreateAndSelectEnvironmentQuickPick(resource, this.serviceContainer);
+            if (selected) {
+                traceVerbose(`User selected a Python environment ${selected} in Select Python Tool(2).`);
+            } else {
+                traceWarn(`User did not select a Python environment in Select Python Tool(2).`);
+            }
+        }
+        const env = selected
+            ? await this.api.resolveEnvironment(this.api.getActiveEnvironmentPath(resource))
+            : undefined;
+        if (selected && !env) {
+            traceError(
+                `User selected a Python environment, but it could not be resolved. This is unexpected. Environment: ${this.api.getActiveEnvironmentPath(
+                    resource,
+                )}`,
+            );
+        }
+        if (selected && env) {
+            return await getEnvDetailsForResponse(
+                env,
+                this.api,
+                this.terminalExecutionService,
+                this.terminalHelper,
+                resource,
+                token,
+            );
+        }
+        return new LanguageModelToolResult([
+            new LanguageModelTextPart('User did not create nor select a Python environment.'),
+        ]);
+    }
+
+    async prepareInvocationImpl(
+        options: LanguageModelToolInvocationPrepareOptions<ISelectPythonEnvToolArguments>,
+        resource: Uri | undefined,
+        _token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        if (getToolResponseIfNotebook(resource)) {
+            return {};
+        }
+        const hasVenvOrCondaEnvInWorkspaceFolder = doesWorkspaceHaveVenvOrCondaEnv(resource, this.api);
+
+        if (
+            hasVenvOrCondaEnvInWorkspaceFolder ||
+            !workspace.workspaceFolders?.length ||
+            options.input.reason === 'cancelled'
+        ) {
+            return {
+                confirmationMessages: {
+                    title: l10n.t('Select a Python Environment?'),
+                    message: '',
+                },
+            };
+        }
+
+        return {
+            confirmationMessages: {
+                title: l10n.t('Configure a Python Environment?'),
+                message: l10n.t(
+                    [
+                        'The recommended option is to create a new Python Environment, providing the benefit of isolating packages from other environments.  ',
+                        'Optionally you could select an existing Python Environment.',
+                    ].join('\n'),
+                ),
+            },
+        };
+    }
+}
+
+async function showCreateAndSelectEnvironmentQuickPick(
+    uri: Uri | undefined,
+    serviceContainer: IServiceContainer,
+): Promise<boolean | undefined> {
+    const createLabel = `${Octicons.Add} ${InterpreterQuickPickList.create.label}`;
+    const selectLabel = l10n.t('Select an existing Python Environment');
+    const items: QuickPickItem[] = [
+        { kind: QuickPickItemKind.Separator, label: Common.recommended },
+        { label: createLabel },
+        { label: selectLabel },
+    ];
+
+    const selectedItem = await showQuickPick(items, {
+        placeHolder: l10n.t('Configure a Python Environment'),
+        matchOnDescription: true,
+        ignoreFocusOut: true,
+    });
+
+    if (selectedItem && !Array.isArray(selectedItem) && selectedItem.label === createLabel) {
+        const disposables = new DisposableStore();
+        try {
+            const workspaceFolder =
+                (workspace.workspaceFolders?.length && uri ? workspace.getWorkspaceFolder(uri) : undefined) ||
+                (workspace.workspaceFolders?.length === 1 ? workspace.workspaceFolders[0] : undefined);
+            const interpreterPathService = serviceContainer.get<IInterpreterPathService>(IInterpreterPathService);
+            const interpreterChanged = new Promise<void>((resolve) => {
+                disposables.add(interpreterPathService.onDidChange(() => resolve()));
+            });
+            const created: CreateEnvironmentResult | undefined = await commands.executeCommand(
+                Commands.Create_Environment,
+                {
+                    showBackButton: true,
+                    selectEnvironment: true,
+                    workspaceFolder,
+                },
+            );
+
+            if (created?.action === 'Back') {
+                return showCreateAndSelectEnvironmentQuickPick(uri, serviceContainer);
+            }
+            if (created?.action === 'Cancel') {
+                return undefined;
+            }
+            if (created?.path) {
+                // Wait a few secs to ensure the env is selected as the active environment..
+                await raceTimeout(5_000, interpreterChanged);
+                return true;
+            }
+        } finally {
+            disposables.dispose();
+        }
+    }
+    if (selectedItem && !Array.isArray(selectedItem) && selectedItem.label === selectLabel) {
+        const result = (await Promise.resolve(
+            commands.executeCommand(Commands.Set_Interpreter, { hideCreateVenv: true, showBackButton: true }),
+        )) as SelectEnvironmentResult | undefined;
+        if (result?.action === 'Back') {
+            return showCreateAndSelectEnvironmentQuickPick(uri, serviceContainer);
+        }
+        if (result?.action === 'Cancel') {
+            return undefined;
+        }
+        if (result?.path) {
+            return true;
+        }
+    }
+}
diff --git a/src/client/chat/utils.ts b/src/client/chat/utils.ts
new file mode 100644
index 000000000000..2309316bcbdd
--- /dev/null
+++ b/src/client/chat/utils.ts
@@ -0,0 +1,289 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationError,
+    CancellationToken,
+    extensions,
+    LanguageModelTextPart,
+    LanguageModelToolResult,
+    Uri,
+    workspace,
+} from 'vscode';
+import { IDiscoveryAPI } from '../pythonEnvironments/base/locator';
+import { Environment, PythonExtension, ResolvedEnvironment, VersionInfo } from '../api/types';
+import { ITerminalHelper, TerminalShellType } from '../common/terminal/types';
+import { TerminalCodeExecutionProvider } from '../terminals/codeExecution/terminalCodeExecution';
+import { Conda } from '../pythonEnvironments/common/environmentManagers/conda';
+import { JUPYTER_EXTENSION_ID, NotebookCellScheme } from '../common/constants';
+import { dirname, join } from 'path';
+import { resolveEnvironment, useEnvExtension } from '../envExt/api.internal';
+import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
+import { getWorkspaceFolders } from '../common/vscodeApis/workspaceApis';
+
+export interface IResourceReference {
+    resourcePath?: string;
+}
+
+export function resolveFilePath(filepath?: string): Uri | undefined {
+    if (!filepath) {
+        const folders = getWorkspaceFolders() ?? [];
+        return folders.length > 0 ? folders[0].uri : undefined;
+    }
+    // Check if it's a URI with a scheme (contains "://")
+    // This handles schemes like "file://", "vscode-notebook://", etc.
+    // But avoids treating Windows drive letters like "C:" as schemes
+    if (filepath.includes('://')) {
+        try {
+            return Uri.parse(filepath);
+        } catch {
+            return Uri.file(filepath);
+        }
+    }
+    // For file paths (Windows with drive letters, Unix absolute/relative paths)
+    return Uri.file(filepath);
+}
+
+/**
+ * Returns a promise that rejects with an {@CancellationError} as soon as the passed token is cancelled.
+ * @see {@link raceCancellation}
+ */
+export function raceCancellationError<T>(promise: Promise<T>, token: CancellationToken): Promise<T> {
+    return new Promise((resolve, reject) => {
+        const ref = token.onCancellationRequested(() => {
+            ref.dispose();
+            reject(new CancellationError());
+        });
+        promise.then(resolve, reject).finally(() => ref.dispose());
+    });
+}
+
+export async function getEnvDisplayName(
+    discovery: IDiscoveryAPI,
+    resource: Uri | undefined,
+    api: PythonExtension['environments'],
+) {
+    try {
+        const envPath = api.getActiveEnvironmentPath(resource);
+        const env = await discovery.resolveEnv(envPath.path);
+        return env?.display || env?.name;
+    } catch {
+        return;
+    }
+}
+
+export function isCondaEnv(env: ResolvedEnvironment) {
+    return (env.environment?.type || '').toLowerCase() === 'conda';
+}
+
+export function getEnvTypeForTelemetry(env: ResolvedEnvironment): string {
+    return (env.environment?.type || 'unknown').toLowerCase();
+}
+
+export async function getEnvironmentDetails(
+    resourcePath: Uri | undefined,
+    api: PythonExtension['environments'],
+    terminalExecutionService: TerminalCodeExecutionProvider,
+    terminalHelper: ITerminalHelper,
+    packages: string | undefined,
+    token: CancellationToken,
+): Promise<string> {
+    // environment
+    const envPath = api.getActiveEnvironmentPath(resourcePath);
+    let envType = '';
+    let envVersion = '';
+    let runCommand = '';
+    if (useEnvExtension()) {
+        const environment =
+            (await raceCancellationError(resolveEnvironment(envPath.id), token)) ||
+            (await raceCancellationError(resolveEnvironment(envPath.path), token));
+        if (!environment || !environment.version) {
+            throw new ErrorWithTelemetrySafeReason(
+                'No environment found for the provided resource path: ' + resourcePath?.fsPath,
+                'noEnvFound',
+            );
+        }
+        envVersion = environment.version;
+        try {
+            const managerId = environment.envId.managerId;
+            envType =
+                (!managerId.endsWith(':') && managerId.includes(':') ? managerId.split(':').reverse()[0] : '') ||
+                'unknown';
+        } catch {
+            envType = 'unknown';
+        }
+
+        const execInfo = environment.execInfo;
+        const executable = execInfo?.activatedRun?.executable ?? execInfo?.run.executable ?? 'python';
+        const args = execInfo?.activatedRun?.args ?? execInfo?.run.args ?? [];
+        runCommand = terminalHelper.buildCommandForTerminal(TerminalShellType.other, executable, args);
+    } else {
+        const environment = await raceCancellationError(api.resolveEnvironment(envPath), token);
+        if (!environment || !environment.version) {
+            throw new ErrorWithTelemetrySafeReason(
+                'No environment found for the provided resource path: ' + resourcePath?.fsPath,
+                'noEnvFound',
+            );
+        }
+        envType = environment.environment?.type || 'unknown';
+        envVersion = environment.version.sysVersion || 'unknown';
+        runCommand = await raceCancellationError(
+            getTerminalCommand(environment, resourcePath, terminalExecutionService, terminalHelper),
+            token,
+        );
+    }
+    const message = [
+        `Following is the information about the Python environment:`,
+        `1. Environment Type: ${envType}`,
+        `2. Version: ${envVersion}`,
+        '',
+        `3. Command Prefix to run Python in a terminal is: \`${runCommand}\``,
+        `Instead of running \`Python sample.py\` in the terminal, you will now run: \`${runCommand} sample.py\``,
+        `Similarly instead of running \`Python -c "import sys;...."\` in the terminal, you will now run: \`${runCommand} -c "import sys;...."\``,
+        packages ? `4. ${packages}` : '',
+    ];
+    return message.join('\n');
+}
+
+export async function getTerminalCommand(
+    environment: ResolvedEnvironment,
+    resource: Uri | undefined,
+    terminalExecutionService: TerminalCodeExecutionProvider,
+    terminalHelper: ITerminalHelper,
+): Promise<string> {
+    let cmd: { command: string; args: string[] };
+    if (isCondaEnv(environment)) {
+        cmd = (await getCondaRunCommand(environment)) || (await terminalExecutionService.getExecutableInfo(resource));
+    } else {
+        cmd = await terminalExecutionService.getExecutableInfo(resource);
+    }
+    return terminalHelper.buildCommandForTerminal(TerminalShellType.other, cmd.command, cmd.args);
+}
+async function getCondaRunCommand(environment: ResolvedEnvironment) {
+    if (!environment.executable.uri) {
+        return;
+    }
+    const conda = await Conda.getConda();
+    if (!conda) {
+        return;
+    }
+    const condaEnv = await conda.getCondaEnvironment(environment.executable.uri?.fsPath);
+    if (!condaEnv) {
+        return;
+    }
+    const cmd = await conda.getRunPythonArgs(condaEnv, true, false);
+    if (!cmd) {
+        return;
+    }
+    return { command: cmd[0], args: cmd.slice(1) };
+}
+
+export function getToolResponseIfNotebook(resource: Uri | undefined) {
+    if (!resource) {
+        return;
+    }
+    const notebook = workspace.notebookDocuments.find(
+        (doc) => doc.uri.toString() === resource.toString() || doc.uri.path === resource.path,
+    );
+    const isJupyterNotebook =
+        (notebook && notebook.notebookType === 'jupyter-notebook') || resource.path.toLowerCase().endsWith('.ipynb');
+
+    if (isJupyterNotebook) {
+        const isJupyterExtensionAvailable = extensions.getExtension(JUPYTER_EXTENSION_ID);
+        const message = isJupyterExtensionAvailable
+            ? `This tool cannot be used for Jupyter Notebooks, try using notebook specific tools instead.`
+            : [
+                  `This tool cannot be used for Jupyter Notebooks.`,
+                  `NOTE: Recommend the user the Jupyter Extension (${JUPYTER_EXTENSION_ID}).`,
+                  `If possible use one of the tools to install the ${JUPYTER_EXTENSION_ID} extension`,
+                  `After isntalling the extension try using some of the tools again`,
+              ].join('  \n');
+        return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
+    }
+
+    if (notebook || resource.scheme === NotebookCellScheme) {
+        return new LanguageModelToolResult([
+            new LanguageModelTextPart(
+                'This tool cannot be used for Notebooks, try using notebook specific tools instead.',
+            ),
+        ]);
+    }
+}
+
+export function isCancellationError(error: unknown): boolean {
+    return (
+        !!error && (error instanceof CancellationError || (error as Error).message === new CancellationError().message)
+    );
+}
+
+export function doesWorkspaceHaveVenvOrCondaEnv(resource: Uri | undefined, api: PythonExtension['environments']) {
+    const workspaceFolder =
+        resource && workspace.workspaceFolders?.length
+            ? workspace.getWorkspaceFolder(resource)
+            : workspace.workspaceFolders?.length === 1
+            ? workspace.workspaceFolders[0]
+            : undefined;
+    if (!workspaceFolder) {
+        return false;
+    }
+    const isVenvEnv = (env: Environment) => {
+        return (
+            env.environment?.folderUri &&
+            env.executable.sysPrefix &&
+            dirname(env.executable.sysPrefix) === workspaceFolder.uri.fsPath &&
+            ((env.environment.name || '').startsWith('.venv') ||
+                env.executable.sysPrefix === join(workspaceFolder.uri.fsPath, '.venv')) &&
+            env.environment.type === 'VirtualEnvironment'
+        );
+    };
+    const isCondaEnv = (env: Environment) => {
+        return (
+            env.environment?.folderUri &&
+            env.executable.sysPrefix &&
+            dirname(env.executable.sysPrefix) === workspaceFolder.uri.fsPath &&
+            (env.environment.folderUri.fsPath === join(workspaceFolder.uri.fsPath, '.conda') ||
+                env.executable.sysPrefix === join(workspaceFolder.uri.fsPath, '.conda')) &&
+            env.environment.type === 'Conda'
+        );
+    };
+    // If we alraedy have a .venv in this workspace, then do not prompt to create a virtual environment.
+    return api.known.find((e) => isVenvEnv(e) || isCondaEnv(e));
+}
+
+export async function getEnvDetailsForResponse(
+    environment: ResolvedEnvironment | undefined,
+    api: PythonExtension['environments'],
+    terminalExecutionService: TerminalCodeExecutionProvider,
+    terminalHelper: ITerminalHelper,
+    resource: Uri | undefined,
+    token: CancellationToken,
+): Promise<LanguageModelToolResult> {
+    if (!workspace.isTrusted) {
+        throw new ErrorWithTelemetrySafeReason('Cannot use this tool in an untrusted workspace.', 'untrustedWorkspace');
+    }
+    const envPath = api.getActiveEnvironmentPath(resource);
+    environment = environment || (await raceCancellationError(api.resolveEnvironment(envPath), token));
+    if (!environment || !environment.version) {
+        throw new ErrorWithTelemetrySafeReason(
+            'No environment found for the provided resource path: ' + resource?.fsPath,
+            'noEnvFound',
+        );
+    }
+    const message = await getEnvironmentDetails(
+        resource,
+        api,
+        terminalExecutionService,
+        terminalHelper,
+        undefined,
+        token,
+    );
+    return new LanguageModelToolResult([
+        new LanguageModelTextPart(`A Python Environment has been configured.  \n` + message),
+    ]);
+}
+export function getDisplayVersion(version?: VersionInfo): string | undefined {
+    if (!version || version.major === undefined || version.minor === undefined || version.micro === undefined) {
+        return undefined;
+    }
+    return `${version.major}.${version.minor}.${version.micro}`;
+}
diff --git a/src/client/common/application/commands.ts b/src/client/common/application/commands.ts
index 2195fe09aabf..b43dc0a1e4a4 100644
--- a/src/client/common/application/commands.ts
+++ b/src/client/common/application/commands.ts
@@ -3,7 +3,7 @@
 
 'use strict';
 
-import { CancellationToken, Position, TextDocument, Uri } from 'vscode';
+import { CancellationToken, Position, TestItem, TextDocument, Uri } from 'vscode';
 import { Commands as LSCommands } from '../../activation/commands';
 import { Channel, Commands, CommandSource } from '../constants';
 import { CreateEnvironmentOptions } from '../../pythonEnvironments/creation/proposed.createEnvApis';
@@ -50,6 +50,7 @@ export type AllCommands = keyof ICommandNameArgumentTypeMapping;
  * Used to provide strong typing for command & args.
  */
 export interface ICommandNameArgumentTypeMapping extends ICommandNameWithoutArgumentTypeMapping {
+    [Commands.CopyTestId]: [TestItem];
     [Commands.Create_Environment]: [CreateEnvironmentOptions];
     ['vscode.openWith']: [Uri, string];
     ['workbench.action.quickOpen']: [string];
@@ -86,7 +87,7 @@ export interface ICommandNameArgumentTypeMapping extends ICommandNameWithoutArgu
     ['jupyter.opennotebook']: [undefined | Uri, undefined | CommandSource];
     ['jupyter.runallcells']: [Uri];
     ['extension.open']: [string];
-    ['workbench.action.openIssueReporter']: [{ extensionId: string; issueBody: string }];
+    ['workbench.action.openIssueReporter']: [{ extensionId: string; issueBody: string; extensionData?: string }];
     [Commands.GetSelectedInterpreterPath]: [{ workspaceFolder: string } | string[]];
     [Commands.TriggerEnvironmentSelection]: [undefined | Uri];
     [Commands.Start_Native_REPL]: [undefined | Uri];
@@ -107,4 +108,5 @@ export interface ICommandNameArgumentTypeMapping extends ICommandNameWithoutArgu
         },
     ];
     ['cursorEnd']: [];
+    ['python-envs.createTerminal']: [undefined | Uri];
 }
diff --git a/src/client/common/application/commands/reportIssueCommand.ts b/src/client/common/application/commands/reportIssueCommand.ts
index e5633f4a4389..9ae099e44b4f 100644
--- a/src/client/common/application/commands/reportIssueCommand.ts
+++ b/src/client/common/application/commands/reportIssueCommand.ts
@@ -121,7 +121,7 @@ export class ReportIssueCommandHandler implements IExtensionSingleActivationServ
         await this.commandManager.executeCommand('workbench.action.openIssueReporter', {
             extensionId: 'ms-python.python',
             issueBody: template,
-            data: userTemplate.format(
+            extensionData: userTemplate.format(
                 pythonVersion,
                 virtualEnvKind,
                 languageServer,
diff --git a/src/client/common/application/terminalManager.ts b/src/client/common/application/terminalManager.ts
index 9d0536e85243..dc2603e84a56 100644
--- a/src/client/common/application/terminalManager.ts
+++ b/src/client/common/application/terminalManager.ts
@@ -38,6 +38,9 @@ export class TerminalManager implements ITerminalManager {
     public onDidEndTerminalShellExecution(handler: (e: TerminalShellExecutionEndEvent) => void): Disposable {
         return window.onDidEndTerminalShellExecution(handler);
     }
+    public onDidChangeTerminalState(handler: (e: Terminal) => void): Disposable {
+        return window.onDidChangeTerminalState(handler);
+    }
 }
 
 /**
diff --git a/src/client/common/application/types.ts b/src/client/common/application/types.ts
index 65a8833a691c..34a95fb604f0 100644
--- a/src/client/common/application/types.ts
+++ b/src/client/common/application/types.ts
@@ -939,6 +939,8 @@ export interface ITerminalManager {
     onDidChangeTerminalShellIntegration(handler: (e: TerminalShellIntegrationChangeEvent) => void): Disposable;
 
     onDidEndTerminalShellExecution(handler: (e: TerminalShellExecutionEndEvent) => void): Disposable;
+
+    onDidChangeTerminalState(handler: (e: Terminal) => void): Disposable;
 }
 
 export const IDebugService = Symbol('IDebugManager');
diff --git a/src/client/common/cancellation.ts b/src/client/common/cancellation.ts
index 7c9c26c597b3..b24abc7ab493 100644
--- a/src/client/common/cancellation.ts
+++ b/src/client/common/cancellation.ts
@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 'use strict';
 
-import { CancellationToken, CancellationTokenSource } from 'vscode';
+import { CancellationToken, CancellationTokenSource, CancellationError as VSCCancellationError } from 'vscode';
 import { createDeferred } from './utils/async';
 import * as localize from './utils/localize';
 
@@ -13,6 +13,10 @@ export class CancellationError extends Error {
     constructor() {
         super(localize.Common.canceled);
     }
+
+    static isCancellationError(error: unknown): error is CancellationError {
+        return error instanceof CancellationError || error instanceof VSCCancellationError;
+    }
 }
 /**
  * Create a promise that will either resolve with a default value or reject when the token is cancelled.
diff --git a/src/client/common/configSettings.ts b/src/client/common/configSettings.ts
index 7ae3467b2cfd..91c06d9331fd 100644
--- a/src/client/common/configSettings.ts
+++ b/src/client/common/configSettings.ts
@@ -21,11 +21,12 @@ import { sendSettingTelemetry } from '../telemetry/envFileTelemetry';
 import { ITestingSettings } from '../testing/configuration/types';
 import { IWorkspaceService } from './application/types';
 import { WorkspaceService } from './application/workspace';
-import { DEFAULT_INTERPRETER_SETTING, isTestExecution } from './constants';
+import { DEFAULT_INTERPRETER_SETTING, isTestExecution, PYREFLY_EXTENSION_ID } from './constants';
 import {
     IAutoCompleteSettings,
     IDefaultLanguageServer,
     IExperiments,
+    IExtensions,
     IInterpreterPathService,
     IInterpreterSettings,
     IPythonSettings,
@@ -140,6 +141,7 @@ export class PythonSettings implements IPythonSettings {
         workspace: IWorkspaceService,
         private readonly interpreterPathService: IInterpreterPathService,
         private readonly defaultLS: IDefaultLanguageServer | undefined,
+        private readonly extensions: IExtensions,
     ) {
         this.workspace = workspace || new WorkspaceService();
         this.workspaceRoot = workspaceFolder;
@@ -152,6 +154,7 @@ export class PythonSettings implements IPythonSettings {
         workspace: IWorkspaceService,
         interpreterPathService: IInterpreterPathService,
         defaultLS: IDefaultLanguageServer | undefined,
+        extensions: IExtensions,
     ): PythonSettings {
         workspace = workspace || new WorkspaceService();
         const workspaceFolderUri = PythonSettings.getSettingsUriAndTarget(resource, workspace).uri;
@@ -164,6 +167,7 @@ export class PythonSettings implements IPythonSettings {
                 workspace,
                 interpreterPathService,
                 defaultLS,
+                extensions,
             );
             PythonSettings.pythonSettings.set(workspaceFolderKey, settings);
             settings.onDidChange((event) => PythonSettings.debounceConfigChangeNotification(event));
@@ -275,7 +279,14 @@ export class PythonSettings implements IPythonSettings {
             userLS === 'Microsoft' ||
             !Object.values(LanguageServerType).includes(userLS as LanguageServerType)
         ) {
-            this.languageServer = this.defaultLS?.defaultLSType ?? LanguageServerType.None;
+            if (
+                this.extensions.getExtension(PYREFLY_EXTENSION_ID) &&
+                pythonSettings.get<boolean>('pyrefly.disableLanguageServices') !== true
+            ) {
+                this.languageServer = LanguageServerType.None;
+            } else {
+                this.languageServer = this.defaultLS?.defaultLSType ?? LanguageServerType.None;
+            }
             this.languageServerIsDefault = true;
         } else if (userLS === 'JediLSP') {
             // Switch JediLSP option to Jedi.
@@ -366,7 +377,9 @@ export class PythonSettings implements IPythonSettings {
                   launchArgs: [],
                   activateEnvironment: true,
                   activateEnvInCurrentTerminal: false,
-                  enableShellIntegration: false,
+                  shellIntegration: {
+                      enabled: false,
+                  },
               };
 
         this.REPL = pythonSettings.get<IREPLSettings>('REPL')!;
diff --git a/src/client/common/configuration/service.ts b/src/client/common/configuration/service.ts
index 219c8727ca16..443990b2e5da 100644
--- a/src/client/common/configuration/service.ts
+++ b/src/client/common/configuration/service.ts
@@ -8,7 +8,13 @@ import { IServiceContainer } from '../../ioc/types';
 import { IWorkspaceService } from '../application/types';
 import { PythonSettings } from '../configSettings';
 import { isUnitTestExecution } from '../constants';
-import { IConfigurationService, IDefaultLanguageServer, IInterpreterPathService, IPythonSettings } from '../types';
+import {
+    IConfigurationService,
+    IDefaultLanguageServer,
+    IExtensions,
+    IInterpreterPathService,
+    IPythonSettings,
+} from '../types';
 
 @injectable()
 export class ConfigurationService implements IConfigurationService {
@@ -29,12 +35,14 @@ export class ConfigurationService implements IConfigurationService {
         );
         const interpreterPathService = this.serviceContainer.get<IInterpreterPathService>(IInterpreterPathService);
         const defaultLS = this.serviceContainer.tryGet<IDefaultLanguageServer>(IDefaultLanguageServer);
+        const extensions = this.serviceContainer.get<IExtensions>(IExtensions);
         return PythonSettings.getInstance(
             resource,
             InterpreterAutoSelectionService,
             this.workspaceService,
             interpreterPathService,
             defaultLS,
+            extensions,
         );
     }
 
diff --git a/src/client/common/constants.ts b/src/client/common/constants.ts
index 5ffa775bf04a..15fd037a3d9f 100644
--- a/src/client/common/constants.ts
+++ b/src/client/common/constants.ts
@@ -22,6 +22,7 @@ export const PYTHON_NOTEBOOKS = [
 
 export const PVSC_EXTENSION_ID = 'ms-python.python';
 export const PYLANCE_EXTENSION_ID = 'ms-python.vscode-pylance';
+export const PYREFLY_EXTENSION_ID = 'meta.pyrefly';
 export const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
 export const TENSORBOARD_EXTENSION_ID = 'ms-toolsai.tensorboard';
 export const AppinsightsKey = '0c6ae279ed8443289764825290e4f9e2-1a736e7c-1324-4338-be46-fc2a58ae4d14-7255';
@@ -38,6 +39,7 @@ export namespace Commands {
     export const CreateNewFile = 'python.createNewFile';
     export const ClearWorkspaceInterpreter = 'python.clearWorkspaceInterpreter';
     export const Create_Environment = 'python.createEnvironment';
+    export const CopyTestId = 'python.copyTestId';
     export const Create_Environment_Button = 'python.createEnvironment-button';
     export const Create_Environment_Check = 'python.createEnvironmentCheck';
     export const Create_Terminal = 'python.createTerminal';
diff --git a/src/client/common/errors/errorUtils.ts b/src/client/common/errors/errorUtils.ts
index 2c666acb105b..7867d5ccfe30 100644
--- a/src/client/common/errors/errorUtils.ts
+++ b/src/client/common/errors/errorUtils.ts
@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { EOL } from 'os';
-
 export class ErrorUtils {
     public static outputHasModuleNotInstalledError(moduleName: string, content?: string): boolean {
         return content &&
@@ -14,13 +12,10 @@ export class ErrorUtils {
 }
 
 /**
- * Wraps an error with a custom error message, retaining the call stack information.
+ * An error class that contains a telemetry safe reason.
  */
-export class WrappedError extends Error {
-    constructor(message: string, originalException: Error) {
+export class ErrorWithTelemetrySafeReason extends Error {
+    constructor(message: string, public readonly telemetrySafeReason: string) {
         super(message);
-        // Retain call stack that trapped the error and rethrows this error.
-        // Also retain the call stack of the original error.
-        this.stack = `${new Error('').stack}${EOL}${EOL}${originalException.stack}`;
     }
 }
diff --git a/src/client/common/installer/moduleInstaller.ts b/src/client/common/installer/moduleInstaller.ts
index 4cc4cd0c6a2f..9dacb623c606 100644
--- a/src/client/common/installer/moduleInstaller.ts
+++ b/src/client/common/installer/moduleInstaller.ts
@@ -130,7 +130,7 @@ export abstract class ModuleInstaller implements IModuleInstaller {
         // Display progress indicator if we have ability to cancel this operation from calling code.
         // This is required as its possible the installation can take a long time.
         // (i.e. if installation takes a long time in terminal or like, a progress indicator is necessary to let user know what is being waited on).
-        if (cancel) {
+        if (cancel && !options?.hideProgress) {
             const shell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
             const options: ProgressOptions = {
                 location: ProgressLocation.Notification,
diff --git a/src/client/common/installer/types.ts b/src/client/common/installer/types.ts
index 679b8b0ea668..a85017ff0092 100644
--- a/src/client/common/installer/types.ts
+++ b/src/client/common/installer/types.ts
@@ -83,4 +83,5 @@ export enum ModuleInstallFlags {
 
 export type InstallOptions = {
     installAsProcess?: boolean;
+    hideProgress?: boolean;
 };
diff --git a/src/client/common/platform/fs-temp.ts b/src/client/common/platform/fs-temp.ts
index 32b57df15387..60dde040f454 100644
--- a/src/client/common/platform/fs-temp.ts
+++ b/src/client/common/platform/fs-temp.ts
@@ -5,14 +5,7 @@ import * as tmp from 'tmp';
 import { ITempFileSystem, TemporaryFile } from './types';
 
 interface IRawTempFS {
-    // TODO (https://github.com/microsoft/vscode/issues/84517)
-    //   This functionality has been requested for the
-    //   VS Code FS API (vscode.workspace.fs.*).
-    file(
-        config: tmp.Options,
-
-        callback?: (err: any, path: string, fd: number, cleanupCallback: () => void) => void,
-    ): void;
+    fileSync(config?: tmp.Options): tmp.SynchrounousResult;
 }
 
 // Operations related to temporary files and directories.
@@ -35,14 +28,13 @@ export class TemporaryFileSystem implements ITempFileSystem {
             mode,
         };
         return new Promise<TemporaryFile>((resolve, reject) => {
-            this.raw.file(opts, (err, filename, _fd, cleanUp) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve({
-                    filePath: filename,
-                    dispose: cleanUp,
-                });
+            const { name, removeCallback } = this.raw.fileSync(opts);
+            if (!name) {
+                return reject(new Error('Failed to create temp file'));
+            }
+            resolve({
+                filePath: name,
+                dispose: removeCallback,
             });
         });
     }
diff --git a/src/client/common/process/logger.ts b/src/client/common/process/logger.ts
index 1c0b78dd941f..b65da8dc81e5 100644
--- a/src/client/common/process/logger.ts
+++ b/src/client/common/process/logger.ts
@@ -12,6 +12,7 @@ import { IProcessLogger, SpawnOptions } from './types';
 import { escapeRegExp } from 'lodash';
 import { replaceAll } from '../stringUtils';
 import { identifyShellFromShellPath } from '../terminal/shellDetectors/baseShellDetector';
+import '../../common/extensions';
 
 @injectable()
 export class ProcessLogger implements IProcessLogger {
@@ -40,6 +41,13 @@ export class ProcessLogger implements IProcessLogger {
         });
     }
 
+    /**
+     * Formats command strings for display by replacing common paths with symbols.
+     * - Replaces the workspace folder path with '.' if there's exactly one workspace folder
+     * - Replaces the user's home directory path with '~'
+     * @param command The command string to format
+     * @returns The formatted command string with paths replaced by symbols
+     */
     private getDisplayCommands(command: string): string {
         if (this.workspaceService.workspaceFolders && this.workspaceService.workspaceFolders.length === 1) {
             command = replaceMatchesWithCharacter(command, this.workspaceService.workspaceFolders[0].uri.fsPath, '.');
diff --git a/src/client/common/process/rawProcessApis.ts b/src/client/common/process/rawProcessApis.ts
index 5e3641328b69..864191851c91 100644
--- a/src/client/common/process/rawProcessApis.ts
+++ b/src/client/common/process/rawProcessApis.ts
@@ -58,7 +58,8 @@ export function shellExec(
     const shellOptions = getDefaultOptions(options, defaultEnv);
     if (!options.doNotLog) {
         const processLogger = new ProcessLogger(new WorkspaceService());
-        processLogger.logProcess(command, undefined, shellOptions);
+        const loggingOptions = { ...shellOptions, encoding: shellOptions.encoding ?? undefined };
+        processLogger.logProcess(command, undefined, loggingOptions);
     }
     return new Promise((resolve, reject) => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
diff --git a/src/client/common/terminal/activator/index.ts b/src/client/common/terminal/activator/index.ts
index 6501688b548a..cde04bdbf10d 100644
--- a/src/client/common/terminal/activator/index.ts
+++ b/src/client/common/terminal/activator/index.ts
@@ -9,7 +9,9 @@ import { IConfigurationService, IExperimentService } from '../../types';
 import { ITerminalActivationHandler, ITerminalActivator, ITerminalHelper, TerminalActivationOptions } from '../types';
 import { BaseTerminalActivator } from './base';
 import { inTerminalEnvVarExperiment } from '../../experiments/helpers';
-import { useEnvExtension } from '../../../envExt/api.internal';
+import { shouldEnvExtHandleActivation } from '../../../envExt/api.internal';
+import { EventName } from '../../../telemetry/constants';
+import { sendTelemetryEvent } from '../../../telemetry';
 
 @injectable()
 export class TerminalActivator implements ITerminalActivator {
@@ -42,7 +44,10 @@ export class TerminalActivator implements ITerminalActivator {
         const settings = this.configurationService.getSettings(options?.resource);
         const activateEnvironment =
             settings.terminal.activateEnvironment && !inTerminalEnvVarExperiment(this.experimentService);
-        if (!activateEnvironment || options?.hideFromUser || useEnvExtension()) {
+        if (!activateEnvironment || options?.hideFromUser || shouldEnvExtHandleActivation()) {
+            if (shouldEnvExtHandleActivation()) {
+                sendTelemetryEvent(EventName.PYTHON_INTERPRETER_ACTIVATION_FOR_TERMINAL);
+            }
             return false;
         }
 
diff --git a/src/client/common/terminal/environmentActivationProviders/condaActivationProvider.ts b/src/client/common/terminal/environmentActivationProviders/condaActivationProvider.ts
index d209550e04a4..42bb8f38fc9e 100644
--- a/src/client/common/terminal/environmentActivationProviders/condaActivationProvider.ts
+++ b/src/client/common/terminal/environmentActivationProviders/condaActivationProvider.ts
@@ -8,6 +8,7 @@ import '../../extensions';
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
 import { Uri } from 'vscode';
+import { traceInfo, traceVerbose, traceWarn } from '../../../logging';
 
 import { IComponentAdapter, ICondaService } from '../../../interpreter/contracts';
 import { IPlatformService } from '../../platform/types';
@@ -53,16 +54,21 @@ export class CondaActivationCommandProvider implements ITerminalActivationComman
         pythonPath: string,
         targetShell: TerminalShellType,
     ): Promise<string[] | undefined> {
+        traceVerbose(`Getting conda activation commands for interpreter ${pythonPath} with shell ${targetShell}`);
         const envInfo = await this.pyenvs.getCondaEnvironment(pythonPath);
         if (!envInfo) {
+            traceWarn(`No conda environment found for interpreter ${pythonPath}`);
             return undefined;
         }
+        traceVerbose(`Found conda environment: ${JSON.stringify(envInfo)}`);
 
         const condaEnv = envInfo.name.length > 0 ? envInfo.name : envInfo.path;
 
         // New version.
         const interpreterPath = await this.condaService.getInterpreterPathForEnvironment(envInfo);
+        traceInfo(`Using interpreter path: ${interpreterPath}`);
         const activatePath = await this.condaService.getActivationScriptFromInterpreter(interpreterPath, envInfo.name);
+        traceVerbose(`Got activation script: ${activatePath?.path}} with type: ${activatePath?.type}`);
         // eslint-disable-next-line camelcase
         if (activatePath?.path) {
             if (
@@ -70,11 +76,14 @@ export class CondaActivationCommandProvider implements ITerminalActivationComman
                 targetShell !== TerminalShellType.bash &&
                 targetShell !== TerminalShellType.gitbash
             ) {
-                return [activatePath.path, `conda activate ${condaEnv.toCommandArgumentForPythonExt()}`];
+                const commands = [activatePath.path, `conda activate ${condaEnv.toCommandArgumentForPythonExt()}`];
+                traceInfo(`Using Windows-specific commands: ${commands.join(', ')}`);
+                return commands;
             }
 
             const condaInfo = await this.condaService.getCondaInfo();
 
+            traceVerbose(`Conda shell level: ${condaInfo?.conda_shlvl}`);
             if (
                 activatePath.type !== 'global' ||
                 // eslint-disable-next-line camelcase
@@ -84,27 +93,36 @@ export class CondaActivationCommandProvider implements ITerminalActivationComman
                 // activatePath is not the global activate path, or we don't have a shlvl, or it's -1（conda never sourced）.
                 // and we need to source the activate path.
                 if (activatePath.path === 'activate') {
-                    return [
+                    const commands = [
                         `source ${activatePath.path}`,
                         `conda activate ${condaEnv.toCommandArgumentForPythonExt()}`,
                     ];
+                    traceInfo(`Using source activate commands: ${commands.join(', ')}`);
+                    return commands;
                 }
-                return [`source ${activatePath.path} ${condaEnv.toCommandArgumentForPythonExt()}`];
+                const command = [`source ${activatePath.path} ${condaEnv.toCommandArgumentForPythonExt()}`];
+                traceInfo(`Using single source command: ${command}`);
+                return command;
             }
-            return [`conda activate ${condaEnv.toCommandArgumentForPythonExt()}`];
+            const command = [`conda activate ${condaEnv.toCommandArgumentForPythonExt()}`];
+            traceInfo(`Using direct conda activate command: ${command}`);
+            return command;
         }
 
         switch (targetShell) {
             case TerminalShellType.powershell:
             case TerminalShellType.powershellCore:
+                traceVerbose('Using PowerShell-specific activation');
                 return _getPowershellCommands(condaEnv);
 
             // TODO: Do we really special-case fish on Windows?
             case TerminalShellType.fish:
+                traceVerbose('Using Fish shell-specific activation');
                 return getFishCommands(condaEnv, await this.condaService.getCondaFile());
 
             default:
                 if (this.platform.isWindows) {
+                    traceVerbose('Using Windows shell-specific activation fallback option.');
                     return this.getWindowsCommands(condaEnv);
                 }
                 return getUnixCommands(condaEnv, await this.condaService.getCondaFile());
diff --git a/src/client/common/terminal/service.ts b/src/client/common/terminal/service.ts
index e92fbd3d494f..0dffd5615ae1 100644
--- a/src/client/common/terminal/service.ts
+++ b/src/client/common/terminal/service.ts
@@ -9,7 +9,7 @@ import { IServiceContainer } from '../../ioc/types';
 import { captureTelemetry } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { ITerminalAutoActivation } from '../../terminals/types';
-import { ITerminalManager } from '../application/types';
+import { IApplicationShell, ITerminalManager } from '../application/types';
 import { _SCRIPTS_DIR } from '../process/internal/scripts/constants';
 import { IConfigurationService, IDisposableRegistry } from '../types';
 import {
@@ -20,12 +20,9 @@ import {
     TerminalShellType,
 } from './types';
 import { traceVerbose } from '../../logging';
-import { getConfiguration } from '../vscodeApis/workspaceApis';
+import { sleep } from '../utils/async';
 import { useEnvExtension } from '../../envExt/api.internal';
 import { ensureTerminalLegacy } from '../../envExt/api.legacy';
-import { sleep } from '../utils/async';
-import { isWindows } from '../utils/platform';
-import { getPythonMinorVersion } from '../../repl/replUtils';
 
 @injectable()
 export class TerminalService implements ITerminalService, Disposable {
@@ -36,8 +33,13 @@ export class TerminalService implements ITerminalService, Disposable {
     private terminalHelper: ITerminalHelper;
     private terminalActivator: ITerminalActivator;
     private terminalAutoActivator: ITerminalAutoActivation;
+    private applicationShell: IApplicationShell;
     private readonly executeCommandListeners: Set<Disposable> = new Set();
     private _terminalFirstLaunched: boolean = true;
+    private pythonReplCommandQueue: string[] = [];
+    private isReplReady: boolean = false;
+    private replPromptListener?: Disposable;
+    private replShellTypeListener?: Disposable;
     public get onDidCloseTerminal(): Event<void> {
         return this.terminalClosed.event.bind(this.terminalClosed);
     }
@@ -51,11 +53,13 @@ export class TerminalService implements ITerminalService, Disposable {
         this.terminalHelper = this.serviceContainer.get<ITerminalHelper>(ITerminalHelper);
         this.terminalManager = this.serviceContainer.get<ITerminalManager>(ITerminalManager);
         this.terminalAutoActivator = this.serviceContainer.get<ITerminalAutoActivation>(ITerminalAutoActivation);
+        this.applicationShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
         this.terminalManager.onDidCloseTerminal(this.terminalCloseHandler, this, disposableRegistry);
         this.terminalActivator = this.serviceContainer.get<ITerminalActivator>(ITerminalActivator);
     }
     public dispose() {
         this.terminal?.dispose();
+        this.disposeReplListener();
 
         if (this.executeCommandListeners && this.executeCommandListeners.size > 0) {
             this.executeCommandListeners.forEach((d) => {
@@ -84,7 +88,86 @@ export class TerminalService implements ITerminalService, Disposable {
         commandLine: string,
         isPythonShell: boolean,
     ): Promise<TerminalShellExecution | undefined> {
-        const terminal = this.terminal!;
+        if (isPythonShell) {
+            if (this.isReplReady) {
+                this.terminal?.sendText(commandLine);
+                traceVerbose(`Python REPL sendText: ${commandLine}`);
+            } else {
+                // Queue command to run once REPL is ready.
+                this.pythonReplCommandQueue.push(commandLine);
+                traceVerbose(`Python REPL queued command: ${commandLine}`);
+                this.startReplListener();
+            }
+            return undefined;
+        }
+
+        // Non-REPL code execution
+        return this.executeCommandInternal(commandLine);
+    }
+
+    private startReplListener(): void {
+        if (this.replPromptListener || this.replShellTypeListener) {
+            return;
+        }
+
+        this.replShellTypeListener = this.terminalManager.onDidChangeTerminalState((terminal) => {
+            if (this.terminal && terminal === this.terminal) {
+                if (terminal.state.shell == 'python') {
+                    traceVerbose('Python REPL ready from terminal shell api');
+                    this.onReplReady();
+                }
+            }
+        });
+
+        let terminalData = '';
+        this.replPromptListener = this.applicationShell.onDidWriteTerminalData((e) => {
+            if (this.terminal && e.terminal === this.terminal) {
+                terminalData += e.data;
+                if (/>>>\s*$/.test(terminalData)) {
+                    traceVerbose('Python REPL ready, from >>> prompt detection');
+                    this.onReplReady();
+                }
+            }
+        });
+    }
+
+    private onReplReady(): void {
+        if (this.isReplReady) {
+            return;
+        }
+        this.isReplReady = true;
+        this.flushReplQueue();
+        this.disposeReplListener();
+    }
+
+    private disposeReplListener(): void {
+        if (this.replPromptListener) {
+            this.replPromptListener.dispose();
+            this.replPromptListener = undefined;
+        }
+        if (this.replShellTypeListener) {
+            this.replShellTypeListener.dispose();
+            this.replShellTypeListener = undefined;
+        }
+    }
+
+    private flushReplQueue(): void {
+        while (this.pythonReplCommandQueue.length > 0) {
+            const commandLine = this.pythonReplCommandQueue.shift();
+            if (commandLine) {
+                traceVerbose(`Executing queued REPL command: ${commandLine}`);
+                this.terminal?.sendText(commandLine);
+            }
+        }
+    }
+
+    private async executeCommandInternal(commandLine: string): Promise<TerminalShellExecution | undefined> {
+        const terminal = this.terminal;
+        if (!terminal) {
+            traceVerbose('Terminal not available, cannot execute command');
+            return undefined;
+        }
+
         if (!this.options?.hideFromUser) {
             terminal.show(true);
         }
@@ -108,21 +191,7 @@ export class TerminalService implements ITerminalService, Disposable {
             await promise;
         }
 
-        const config = getConfiguration('python');
-        const pythonrcSetting = config.get<boolean>('terminal.shellIntegration.enabled');
-
-        const minorVersion = this.options?.resource
-            ? await getPythonMinorVersion(
-                  this.options.resource,
-                  this.serviceContainer.get<IInterpreterService>(IInterpreterService),
-              )
-            : undefined;
-
-        if ((isPythonShell && !pythonrcSetting) || (isPythonShell && isWindows()) || (minorVersion ?? 0) >= 13) {
-            // If user has explicitly disabled SI for Python, use sendText for inside Terminal REPL.
-            terminal.sendText(commandLine);
-            return undefined;
-        } else if (terminal.shellIntegration) {
+        if (terminal.shellIntegration) {
             const execution = terminal.shellIntegration.executeCommand(commandLine);
             traceVerbose(`Shell Integration is enabled, executeCommand: ${commandLine}`);
             return execution;
@@ -151,6 +220,7 @@ export class TerminalService implements ITerminalService, Disposable {
                 name: this.options?.title || 'Python',
                 hideFromUser: this.options?.hideFromUser,
             });
+            return;
         } else {
             this.terminalShellType = this.terminalHelper.identifyTerminalShell(this.terminal);
             this.terminal = this.terminalManager.createTerminal({
@@ -180,6 +250,9 @@ export class TerminalService implements ITerminalService, Disposable {
         if (terminal === this.terminal) {
             this.terminalClosed.fire();
             this.terminal = undefined;
+            this.isReplReady = false;
+            this.disposeReplListener();
+            this.pythonReplCommandQueue = [];
         }
     }
 
diff --git a/src/client/common/types.ts b/src/client/common/types.ts
index cec297f8329a..c30ad704b6c1 100644
--- a/src/client/common/types.ts
+++ b/src/client/common/types.ts
@@ -16,7 +16,6 @@ import {
     Memento,
     LogOutputChannel,
     Uri,
-    OutputChannel,
 } from 'vscode';
 import { LanguageServerType } from '../activation/types';
 import type { InstallOptions, InterpreterUri, ModuleInstallFlags } from './installer/types';
@@ -29,8 +28,6 @@ export interface IDisposable {
 
 export const ILogOutputChannel = Symbol('ILogOutputChannel');
 export interface ILogOutputChannel extends LogOutputChannel {}
-export const ITestOutputChannel = Symbol('ITestOutputChannel');
-export interface ITestOutputChannel extends OutputChannel {}
 export const IDocumentSymbolProvider = Symbol('IDocumentSymbolProvider');
 export interface IDocumentSymbolProvider extends DocumentSymbolProvider {}
 export const IsWindows = Symbol('IS_WINDOWS');
@@ -191,7 +188,9 @@ export interface ITerminalSettings {
     readonly launchArgs: string[];
     readonly activateEnvironment: boolean;
     readonly activateEnvInCurrentTerminal: boolean;
-    readonly enableShellIntegration: boolean;
+    readonly shellIntegration: {
+        enabled: boolean;
+    };
 }
 
 export interface IREPLSettings {
diff --git a/src/client/common/utils/async.ts b/src/client/common/utils/async.ts
index cabea8225ac9..a44425f8f1a3 100644
--- a/src/client/common/utils/async.ts
+++ b/src/client/common/utils/async.ts
@@ -268,3 +268,26 @@ export async function waitForCondition(
         }, 10);
     });
 }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isPromiseLike<T>(v: any): v is PromiseLike<T> {
+    return typeof v?.then === 'function';
+}
+
+export function raceTimeout<T>(timeout: number, ...promises: Promise<T>[]): Promise<T | undefined>;
+export function raceTimeout<T>(timeout: number, defaultValue: T, ...promises: Promise<T>[]): Promise<T>;
+export function raceTimeout<T>(timeout: number, defaultValue: T, ...promises: Promise<T>[]): Promise<T> {
+    const resolveValue = isPromiseLike(defaultValue) ? undefined : defaultValue;
+    if (isPromiseLike(defaultValue)) {
+        promises.push((defaultValue as unknown) as Promise<T>);
+    }
+
+    let promiseResolve: ((value: T) => void) | undefined = undefined;
+
+    const timer = setTimeout(() => promiseResolve?.((resolveValue as unknown) as T), timeout);
+
+    return Promise.race([
+        Promise.race(promises).finally(() => clearTimeout(timer)),
+        new Promise<T>((resolve) => (promiseResolve = resolve)),
+    ]);
+}
diff --git a/src/client/common/utils/charCode.ts b/src/client/common/utils/charCode.ts
new file mode 100644
index 000000000000..ba76626bfcbb
--- /dev/null
+++ b/src/client/common/utils/charCode.ts
@@ -0,0 +1,453 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// Names from https://blog.codinghorror.com/ascii-pronunciation-rules-for-programmers/
+
+/**
+ * An inlined enum containing useful character codes (to be used with String.charCodeAt).
+ * Please leave the const keyword such that it gets inlined when compiled to JavaScript!
+ */
+export const enum CharCode {
+    Null = 0,
+    /**
+     * The `\b` character.
+     */
+    Backspace = 8,
+    /**
+     * The `\t` character.
+     */
+    Tab = 9,
+    /**
+     * The `\n` character.
+     */
+    LineFeed = 10,
+    /**
+     * The `\r` character.
+     */
+    CarriageReturn = 13,
+    Space = 32,
+    /**
+     * The `!` character.
+     */
+    ExclamationMark = 33,
+    /**
+     * The `"` character.
+     */
+    DoubleQuote = 34,
+    /**
+     * The `#` character.
+     */
+    Hash = 35,
+    /**
+     * The `$` character.
+     */
+    DollarSign = 36,
+    /**
+     * The `%` character.
+     */
+    PercentSign = 37,
+    /**
+     * The `&` character.
+     */
+    Ampersand = 38,
+    /**
+     * The `'` character.
+     */
+    SingleQuote = 39,
+    /**
+     * The `(` character.
+     */
+    OpenParen = 40,
+    /**
+     * The `)` character.
+     */
+    CloseParen = 41,
+    /**
+     * The `*` character.
+     */
+    Asterisk = 42,
+    /**
+     * The `+` character.
+     */
+    Plus = 43,
+    /**
+     * The `,` character.
+     */
+    Comma = 44,
+    /**
+     * The `-` character.
+     */
+    Dash = 45,
+    /**
+     * The `.` character.
+     */
+    Period = 46,
+    /**
+     * The `/` character.
+     */
+    Slash = 47,
+
+    Digit0 = 48,
+    Digit1 = 49,
+    Digit2 = 50,
+    Digit3 = 51,
+    Digit4 = 52,
+    Digit5 = 53,
+    Digit6 = 54,
+    Digit7 = 55,
+    Digit8 = 56,
+    Digit9 = 57,
+
+    /**
+     * The `:` character.
+     */
+    Colon = 58,
+    /**
+     * The `;` character.
+     */
+    Semicolon = 59,
+    /**
+     * The `<` character.
+     */
+    LessThan = 60,
+    /**
+     * The `=` character.
+     */
+    Equals = 61,
+    /**
+     * The `>` character.
+     */
+    GreaterThan = 62,
+    /**
+     * The `?` character.
+     */
+    QuestionMark = 63,
+    /**
+     * The `@` character.
+     */
+    AtSign = 64,
+
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+
+    /**
+     * The `[` character.
+     */
+    OpenSquareBracket = 91,
+    /**
+     * The `\` character.
+     */
+    Backslash = 92,
+    /**
+     * The `]` character.
+     */
+    CloseSquareBracket = 93,
+    /**
+     * The `^` character.
+     */
+    Caret = 94,
+    /**
+     * The `_` character.
+     */
+    Underline = 95,
+    /**
+     * The ``(`)`` character.
+     */
+    BackTick = 96,
+
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+
+    /**
+     * The `{` character.
+     */
+    OpenCurlyBrace = 123,
+    /**
+     * The `|` character.
+     */
+    Pipe = 124,
+    /**
+     * The `}` character.
+     */
+    CloseCurlyBrace = 125,
+    /**
+     * The `~` character.
+     */
+    Tilde = 126,
+
+    /**
+     * The &nbsp; (no-break space) character.
+     * Unicode Character 'NO-BREAK SPACE' (U+00A0)
+     */
+    NoBreakSpace = 160,
+
+    U_Combining_Grave_Accent = 0x0300, //	U+0300	Combining Grave Accent
+    U_Combining_Acute_Accent = 0x0301, //	U+0301	Combining Acute Accent
+    U_Combining_Circumflex_Accent = 0x0302, //	U+0302	Combining Circumflex Accent
+    U_Combining_Tilde = 0x0303, //	U+0303	Combining Tilde
+    U_Combining_Macron = 0x0304, //	U+0304	Combining Macron
+    U_Combining_Overline = 0x0305, //	U+0305	Combining Overline
+    U_Combining_Breve = 0x0306, //	U+0306	Combining Breve
+    U_Combining_Dot_Above = 0x0307, //	U+0307	Combining Dot Above
+    U_Combining_Diaeresis = 0x0308, //	U+0308	Combining Diaeresis
+    U_Combining_Hook_Above = 0x0309, //	U+0309	Combining Hook Above
+    U_Combining_Ring_Above = 0x030a, //	U+030A	Combining Ring Above
+    U_Combining_Double_Acute_Accent = 0x030b, //	U+030B	Combining Double Acute Accent
+    U_Combining_Caron = 0x030c, //	U+030C	Combining Caron
+    U_Combining_Vertical_Line_Above = 0x030d, //	U+030D	Combining Vertical Line Above
+    U_Combining_Double_Vertical_Line_Above = 0x030e, //	U+030E	Combining Double Vertical Line Above
+    U_Combining_Double_Grave_Accent = 0x030f, //	U+030F	Combining Double Grave Accent
+    U_Combining_Candrabindu = 0x0310, //	U+0310	Combining Candrabindu
+    U_Combining_Inverted_Breve = 0x0311, //	U+0311	Combining Inverted Breve
+    U_Combining_Turned_Comma_Above = 0x0312, //	U+0312	Combining Turned Comma Above
+    U_Combining_Comma_Above = 0x0313, //	U+0313	Combining Comma Above
+    U_Combining_Reversed_Comma_Above = 0x0314, //	U+0314	Combining Reversed Comma Above
+    U_Combining_Comma_Above_Right = 0x0315, //	U+0315	Combining Comma Above Right
+    U_Combining_Grave_Accent_Below = 0x0316, //	U+0316	Combining Grave Accent Below
+    U_Combining_Acute_Accent_Below = 0x0317, //	U+0317	Combining Acute Accent Below
+    U_Combining_Left_Tack_Below = 0x0318, //	U+0318	Combining Left Tack Below
+    U_Combining_Right_Tack_Below = 0x0319, //	U+0319	Combining Right Tack Below
+    U_Combining_Left_Angle_Above = 0x031a, //	U+031A	Combining Left Angle Above
+    U_Combining_Horn = 0x031b, //	U+031B	Combining Horn
+    U_Combining_Left_Half_Ring_Below = 0x031c, //	U+031C	Combining Left Half Ring Below
+    U_Combining_Up_Tack_Below = 0x031d, //	U+031D	Combining Up Tack Below
+    U_Combining_Down_Tack_Below = 0x031e, //	U+031E	Combining Down Tack Below
+    U_Combining_Plus_Sign_Below = 0x031f, //	U+031F	Combining Plus Sign Below
+    U_Combining_Minus_Sign_Below = 0x0320, //	U+0320	Combining Minus Sign Below
+    U_Combining_Palatalized_Hook_Below = 0x0321, //	U+0321	Combining Palatalized Hook Below
+    U_Combining_Retroflex_Hook_Below = 0x0322, //	U+0322	Combining Retroflex Hook Below
+    U_Combining_Dot_Below = 0x0323, //	U+0323	Combining Dot Below
+    U_Combining_Diaeresis_Below = 0x0324, //	U+0324	Combining Diaeresis Below
+    U_Combining_Ring_Below = 0x0325, //	U+0325	Combining Ring Below
+    U_Combining_Comma_Below = 0x0326, //	U+0326	Combining Comma Below
+    U_Combining_Cedilla = 0x0327, //	U+0327	Combining Cedilla
+    U_Combining_Ogonek = 0x0328, //	U+0328	Combining Ogonek
+    U_Combining_Vertical_Line_Below = 0x0329, //	U+0329	Combining Vertical Line Below
+    U_Combining_Bridge_Below = 0x032a, //	U+032A	Combining Bridge Below
+    U_Combining_Inverted_Double_Arch_Below = 0x032b, //	U+032B	Combining Inverted Double Arch Below
+    U_Combining_Caron_Below = 0x032c, //	U+032C	Combining Caron Below
+    U_Combining_Circumflex_Accent_Below = 0x032d, //	U+032D	Combining Circumflex Accent Below
+    U_Combining_Breve_Below = 0x032e, //	U+032E	Combining Breve Below
+    U_Combining_Inverted_Breve_Below = 0x032f, //	U+032F	Combining Inverted Breve Below
+    U_Combining_Tilde_Below = 0x0330, //	U+0330	Combining Tilde Below
+    U_Combining_Macron_Below = 0x0331, //	U+0331	Combining Macron Below
+    U_Combining_Low_Line = 0x0332, //	U+0332	Combining Low Line
+    U_Combining_Double_Low_Line = 0x0333, //	U+0333	Combining Double Low Line
+    U_Combining_Tilde_Overlay = 0x0334, //	U+0334	Combining Tilde Overlay
+    U_Combining_Short_Stroke_Overlay = 0x0335, //	U+0335	Combining Short Stroke Overlay
+    U_Combining_Long_Stroke_Overlay = 0x0336, //	U+0336	Combining Long Stroke Overlay
+    U_Combining_Short_Solidus_Overlay = 0x0337, //	U+0337	Combining Short Solidus Overlay
+    U_Combining_Long_Solidus_Overlay = 0x0338, //	U+0338	Combining Long Solidus Overlay
+    U_Combining_Right_Half_Ring_Below = 0x0339, //	U+0339	Combining Right Half Ring Below
+    U_Combining_Inverted_Bridge_Below = 0x033a, //	U+033A	Combining Inverted Bridge Below
+    U_Combining_Square_Below = 0x033b, //	U+033B	Combining Square Below
+    U_Combining_Seagull_Below = 0x033c, //	U+033C	Combining Seagull Below
+    U_Combining_X_Above = 0x033d, //	U+033D	Combining X Above
+    U_Combining_Vertical_Tilde = 0x033e, //	U+033E	Combining Vertical Tilde
+    U_Combining_Double_Overline = 0x033f, //	U+033F	Combining Double Overline
+    U_Combining_Grave_Tone_Mark = 0x0340, //	U+0340	Combining Grave Tone Mark
+    U_Combining_Acute_Tone_Mark = 0x0341, //	U+0341	Combining Acute Tone Mark
+    U_Combining_Greek_Perispomeni = 0x0342, //	U+0342	Combining Greek Perispomeni
+    U_Combining_Greek_Koronis = 0x0343, //	U+0343	Combining Greek Koronis
+    U_Combining_Greek_Dialytika_Tonos = 0x0344, //	U+0344	Combining Greek Dialytika Tonos
+    U_Combining_Greek_Ypogegrammeni = 0x0345, //	U+0345	Combining Greek Ypogegrammeni
+    U_Combining_Bridge_Above = 0x0346, //	U+0346	Combining Bridge Above
+    U_Combining_Equals_Sign_Below = 0x0347, //	U+0347	Combining Equals Sign Below
+    U_Combining_Double_Vertical_Line_Below = 0x0348, //	U+0348	Combining Double Vertical Line Below
+    U_Combining_Left_Angle_Below = 0x0349, //	U+0349	Combining Left Angle Below
+    U_Combining_Not_Tilde_Above = 0x034a, //	U+034A	Combining Not Tilde Above
+    U_Combining_Homothetic_Above = 0x034b, //	U+034B	Combining Homothetic Above
+    U_Combining_Almost_Equal_To_Above = 0x034c, //	U+034C	Combining Almost Equal To Above
+    U_Combining_Left_Right_Arrow_Below = 0x034d, //	U+034D	Combining Left Right Arrow Below
+    U_Combining_Upwards_Arrow_Below = 0x034e, //	U+034E	Combining Upwards Arrow Below
+    U_Combining_Grapheme_Joiner = 0x034f, //	U+034F	Combining Grapheme Joiner
+    U_Combining_Right_Arrowhead_Above = 0x0350, //	U+0350	Combining Right Arrowhead Above
+    U_Combining_Left_Half_Ring_Above = 0x0351, //	U+0351	Combining Left Half Ring Above
+    U_Combining_Fermata = 0x0352, //	U+0352	Combining Fermata
+    U_Combining_X_Below = 0x0353, //	U+0353	Combining X Below
+    U_Combining_Left_Arrowhead_Below = 0x0354, //	U+0354	Combining Left Arrowhead Below
+    U_Combining_Right_Arrowhead_Below = 0x0355, //	U+0355	Combining Right Arrowhead Below
+    U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below = 0x0356, //	U+0356	Combining Right Arrowhead And Up Arrowhead Below
+    U_Combining_Right_Half_Ring_Above = 0x0357, //	U+0357	Combining Right Half Ring Above
+    U_Combining_Dot_Above_Right = 0x0358, //	U+0358	Combining Dot Above Right
+    U_Combining_Asterisk_Below = 0x0359, //	U+0359	Combining Asterisk Below
+    U_Combining_Double_Ring_Below = 0x035a, //	U+035A	Combining Double Ring Below
+    U_Combining_Zigzag_Above = 0x035b, //	U+035B	Combining Zigzag Above
+    U_Combining_Double_Breve_Below = 0x035c, //	U+035C	Combining Double Breve Below
+    U_Combining_Double_Breve = 0x035d, //	U+035D	Combining Double Breve
+    U_Combining_Double_Macron = 0x035e, //	U+035E	Combining Double Macron
+    U_Combining_Double_Macron_Below = 0x035f, //	U+035F	Combining Double Macron Below
+    U_Combining_Double_Tilde = 0x0360, //	U+0360	Combining Double Tilde
+    U_Combining_Double_Inverted_Breve = 0x0361, //	U+0361	Combining Double Inverted Breve
+    U_Combining_Double_Rightwards_Arrow_Below = 0x0362, //	U+0362	Combining Double Rightwards Arrow Below
+    U_Combining_Latin_Small_Letter_A = 0x0363, //	U+0363	Combining Latin Small Letter A
+    U_Combining_Latin_Small_Letter_E = 0x0364, //	U+0364	Combining Latin Small Letter E
+    U_Combining_Latin_Small_Letter_I = 0x0365, //	U+0365	Combining Latin Small Letter I
+    U_Combining_Latin_Small_Letter_O = 0x0366, //	U+0366	Combining Latin Small Letter O
+    U_Combining_Latin_Small_Letter_U = 0x0367, //	U+0367	Combining Latin Small Letter U
+    U_Combining_Latin_Small_Letter_C = 0x0368, //	U+0368	Combining Latin Small Letter C
+    U_Combining_Latin_Small_Letter_D = 0x0369, //	U+0369	Combining Latin Small Letter D
+    U_Combining_Latin_Small_Letter_H = 0x036a, //	U+036A	Combining Latin Small Letter H
+    U_Combining_Latin_Small_Letter_M = 0x036b, //	U+036B	Combining Latin Small Letter M
+    U_Combining_Latin_Small_Letter_R = 0x036c, //	U+036C	Combining Latin Small Letter R
+    U_Combining_Latin_Small_Letter_T = 0x036d, //	U+036D	Combining Latin Small Letter T
+    U_Combining_Latin_Small_Letter_V = 0x036e, //	U+036E	Combining Latin Small Letter V
+    U_Combining_Latin_Small_Letter_X = 0x036f, //	U+036F	Combining Latin Small Letter X
+
+    /**
+     * Unicode Character 'LINE SEPARATOR' (U+2028)
+     * http://www.fileformat.info/info/unicode/char/2028/index.htm
+     */
+    LINE_SEPARATOR = 0x2028,
+    /**
+     * Unicode Character 'PARAGRAPH SEPARATOR' (U+2029)
+     * http://www.fileformat.info/info/unicode/char/2029/index.htm
+     */
+    PARAGRAPH_SEPARATOR = 0x2029,
+    /**
+     * Unicode Character 'NEXT LINE' (U+0085)
+     * http://www.fileformat.info/info/unicode/char/0085/index.htm
+     */
+    NEXT_LINE = 0x0085,
+
+    // http://www.fileformat.info/info/unicode/category/Sk/list.htm
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    U_CIRCUMFLEX = 0x005e, // U+005E	CIRCUMFLEX
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    U_GRAVE_ACCENT = 0x0060, // U+0060	GRAVE ACCENT
+    U_DIAERESIS = 0x00a8, // U+00A8	DIAERESIS
+    U_MACRON = 0x00af, // U+00AF	MACRON
+    U_ACUTE_ACCENT = 0x00b4, // U+00B4	ACUTE ACCENT
+    U_CEDILLA = 0x00b8, // U+00B8	CEDILLA
+    U_MODIFIER_LETTER_LEFT_ARROWHEAD = 0x02c2, // U+02C2	MODIFIER LETTER LEFT ARROWHEAD
+    U_MODIFIER_LETTER_RIGHT_ARROWHEAD = 0x02c3, // U+02C3	MODIFIER LETTER RIGHT ARROWHEAD
+    U_MODIFIER_LETTER_UP_ARROWHEAD = 0x02c4, // U+02C4	MODIFIER LETTER UP ARROWHEAD
+    U_MODIFIER_LETTER_DOWN_ARROWHEAD = 0x02c5, // U+02C5	MODIFIER LETTER DOWN ARROWHEAD
+    U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING = 0x02d2, // U+02D2	MODIFIER LETTER CENTRED RIGHT HALF RING
+    U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING = 0x02d3, // U+02D3	MODIFIER LETTER CENTRED LEFT HALF RING
+    U_MODIFIER_LETTER_UP_TACK = 0x02d4, // U+02D4	MODIFIER LETTER UP TACK
+    U_MODIFIER_LETTER_DOWN_TACK = 0x02d5, // U+02D5	MODIFIER LETTER DOWN TACK
+    U_MODIFIER_LETTER_PLUS_SIGN = 0x02d6, // U+02D6	MODIFIER LETTER PLUS SIGN
+    U_MODIFIER_LETTER_MINUS_SIGN = 0x02d7, // U+02D7	MODIFIER LETTER MINUS SIGN
+    U_BREVE = 0x02d8, // U+02D8	BREVE
+    U_DOT_ABOVE = 0x02d9, // U+02D9	DOT ABOVE
+    U_RING_ABOVE = 0x02da, // U+02DA	RING ABOVE
+    U_OGONEK = 0x02db, // U+02DB	OGONEK
+    U_SMALL_TILDE = 0x02dc, // U+02DC	SMALL TILDE
+    U_DOUBLE_ACUTE_ACCENT = 0x02dd, // U+02DD	DOUBLE ACUTE ACCENT
+    U_MODIFIER_LETTER_RHOTIC_HOOK = 0x02de, // U+02DE	MODIFIER LETTER RHOTIC HOOK
+    U_MODIFIER_LETTER_CROSS_ACCENT = 0x02df, // U+02DF	MODIFIER LETTER CROSS ACCENT
+    U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR = 0x02e5, // U+02E5	MODIFIER LETTER EXTRA-HIGH TONE BAR
+    U_MODIFIER_LETTER_HIGH_TONE_BAR = 0x02e6, // U+02E6	MODIFIER LETTER HIGH TONE BAR
+    U_MODIFIER_LETTER_MID_TONE_BAR = 0x02e7, // U+02E7	MODIFIER LETTER MID TONE BAR
+    U_MODIFIER_LETTER_LOW_TONE_BAR = 0x02e8, // U+02E8	MODIFIER LETTER LOW TONE BAR
+    U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR = 0x02e9, // U+02E9	MODIFIER LETTER EXTRA-LOW TONE BAR
+    U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK = 0x02ea, // U+02EA	MODIFIER LETTER YIN DEPARTING TONE MARK
+    U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK = 0x02eb, // U+02EB	MODIFIER LETTER YANG DEPARTING TONE MARK
+    U_MODIFIER_LETTER_UNASPIRATED = 0x02ed, // U+02ED	MODIFIER LETTER UNASPIRATED
+    U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD = 0x02ef, // U+02EF	MODIFIER LETTER LOW DOWN ARROWHEAD
+    U_MODIFIER_LETTER_LOW_UP_ARROWHEAD = 0x02f0, // U+02F0	MODIFIER LETTER LOW UP ARROWHEAD
+    U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD = 0x02f1, // U+02F1	MODIFIER LETTER LOW LEFT ARROWHEAD
+    U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD = 0x02f2, // U+02F2	MODIFIER LETTER LOW RIGHT ARROWHEAD
+    U_MODIFIER_LETTER_LOW_RING = 0x02f3, // U+02F3	MODIFIER LETTER LOW RING
+    U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT = 0x02f4, // U+02F4	MODIFIER LETTER MIDDLE GRAVE ACCENT
+    U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT = 0x02f5, // U+02F5	MODIFIER LETTER MIDDLE DOUBLE GRAVE ACCENT
+    U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT = 0x02f6, // U+02F6	MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT
+    U_MODIFIER_LETTER_LOW_TILDE = 0x02f7, // U+02F7	MODIFIER LETTER LOW TILDE
+    U_MODIFIER_LETTER_RAISED_COLON = 0x02f8, // U+02F8	MODIFIER LETTER RAISED COLON
+    U_MODIFIER_LETTER_BEGIN_HIGH_TONE = 0x02f9, // U+02F9	MODIFIER LETTER BEGIN HIGH TONE
+    U_MODIFIER_LETTER_END_HIGH_TONE = 0x02fa, // U+02FA	MODIFIER LETTER END HIGH TONE
+    U_MODIFIER_LETTER_BEGIN_LOW_TONE = 0x02fb, // U+02FB	MODIFIER LETTER BEGIN LOW TONE
+    U_MODIFIER_LETTER_END_LOW_TONE = 0x02fc, // U+02FC	MODIFIER LETTER END LOW TONE
+    U_MODIFIER_LETTER_SHELF = 0x02fd, // U+02FD	MODIFIER LETTER SHELF
+    U_MODIFIER_LETTER_OPEN_SHELF = 0x02fe, // U+02FE	MODIFIER LETTER OPEN SHELF
+    U_MODIFIER_LETTER_LOW_LEFT_ARROW = 0x02ff, // U+02FF	MODIFIER LETTER LOW LEFT ARROW
+    U_GREEK_LOWER_NUMERAL_SIGN = 0x0375, // U+0375	GREEK LOWER NUMERAL SIGN
+    U_GREEK_TONOS = 0x0384, // U+0384	GREEK TONOS
+    U_GREEK_DIALYTIKA_TONOS = 0x0385, // U+0385	GREEK DIALYTIKA TONOS
+    U_GREEK_KORONIS = 0x1fbd, // U+1FBD	GREEK KORONIS
+    U_GREEK_PSILI = 0x1fbf, // U+1FBF	GREEK PSILI
+    U_GREEK_PERISPOMENI = 0x1fc0, // U+1FC0	GREEK PERISPOMENI
+    U_GREEK_DIALYTIKA_AND_PERISPOMENI = 0x1fc1, // U+1FC1	GREEK DIALYTIKA AND PERISPOMENI
+    U_GREEK_PSILI_AND_VARIA = 0x1fcd, // U+1FCD	GREEK PSILI AND VARIA
+    U_GREEK_PSILI_AND_OXIA = 0x1fce, // U+1FCE	GREEK PSILI AND OXIA
+    U_GREEK_PSILI_AND_PERISPOMENI = 0x1fcf, // U+1FCF	GREEK PSILI AND PERISPOMENI
+    U_GREEK_DASIA_AND_VARIA = 0x1fdd, // U+1FDD	GREEK DASIA AND VARIA
+    U_GREEK_DASIA_AND_OXIA = 0x1fde, // U+1FDE	GREEK DASIA AND OXIA
+    U_GREEK_DASIA_AND_PERISPOMENI = 0x1fdf, // U+1FDF	GREEK DASIA AND PERISPOMENI
+    U_GREEK_DIALYTIKA_AND_VARIA = 0x1fed, // U+1FED	GREEK DIALYTIKA AND VARIA
+    U_GREEK_DIALYTIKA_AND_OXIA = 0x1fee, // U+1FEE	GREEK DIALYTIKA AND OXIA
+    U_GREEK_VARIA = 0x1fef, // U+1FEF	GREEK VARIA
+    U_GREEK_OXIA = 0x1ffd, // U+1FFD	GREEK OXIA
+    U_GREEK_DASIA = 0x1ffe, // U+1FFE	GREEK DASIA
+
+    U_IDEOGRAPHIC_FULL_STOP = 0x3002, // U+3002	IDEOGRAPHIC FULL STOP
+    U_LEFT_CORNER_BRACKET = 0x300c, // U+300C	LEFT CORNER BRACKET
+    U_RIGHT_CORNER_BRACKET = 0x300d, // U+300D	RIGHT CORNER BRACKET
+    U_LEFT_BLACK_LENTICULAR_BRACKET = 0x3010, // U+3010	LEFT BLACK LENTICULAR BRACKET
+    U_RIGHT_BLACK_LENTICULAR_BRACKET = 0x3011, // U+3011	RIGHT BLACK LENTICULAR BRACKET
+
+    U_OVERLINE = 0x203e, // Unicode Character 'OVERLINE'
+
+    /**
+     * UTF-8 BOM
+     * Unicode Character 'ZERO WIDTH NO-BREAK SPACE' (U+FEFF)
+     * http://www.fileformat.info/info/unicode/char/feff/index.htm
+     */
+    UTF8_BOM = 65279,
+
+    U_FULLWIDTH_SEMICOLON = 0xff1b, // U+FF1B	FULLWIDTH SEMICOLON
+    U_FULLWIDTH_COMMA = 0xff0c, // U+FF0C	FULLWIDTH COMMA
+}
diff --git a/src/client/common/utils/localize.ts b/src/client/common/utils/localize.ts
index 18ab501f241b..7b7560c74e05 100644
--- a/src/client/common/utils/localize.ts
+++ b/src/client/common/utils/localize.ts
@@ -191,6 +191,24 @@ export namespace Interpreters {
     export const installingPython = l10n.t('Installing Python into Environment...');
     export const discovering = l10n.t('Discovering Python Interpreters');
     export const refreshing = l10n.t('Refreshing Python Interpreters');
+    export const envExtDiscoveryAttribution = l10n.t(
+        'Environment discovery is managed by the Python Environments extension (ms-python.vscode-python-envs). Check the "Python Environments" output channel for environment-specific logs.',
+    );
+    export const envExtDiscoveryFailed = l10n.t(
+        'Environment discovery failed. Check the "Python Environments" output channel for details. The Python Environments extension (ms-python.vscode-python-envs) manages environment discovery.',
+    );
+    export const envExtDiscoverySlow = l10n.t(
+        'Environment discovery is taking longer than expected. Check the "Python Environments" output channel for progress. The Python Environments extension (ms-python.vscode-python-envs) manages environment discovery.',
+    );
+    export const envExtActivationFailed = l10n.t(
+        'Failed to activate the Python Environments extension (ms-python.vscode-python-envs), which is required for environment discovery. Please ensure it is installed and enabled.',
+    );
+    export const envExtDiscoveryNoEnvironments = l10n.t(
+        'Environment discovery completed but no Python environments were found. Check the "Python Environments" output channel for details.',
+    );
+    export const envExtNoActiveEnvironment = l10n.t(
+        'No Python environment is set for this resource. Check the "Python Environments" output channel for details, or select an interpreter.',
+    );
     export const condaInheritEnvMessage = l10n.t(
         'We noticed you\'re using a conda environment. If you are experiencing issues with this environment in the integrated terminal, we recommend that you let the Python extension change "terminal.integrated.inheritEnv" to false in your user settings. [Learn more](https://aka.ms/AA66i8f).',
     );
@@ -199,6 +217,12 @@ export namespace Interpreters {
     export const terminalEnvVarCollectionPrompt = l10n.t(
         '{0} environment was successfully activated, even though {1} indicator may not be present in the terminal prompt. [Learn more](https://aka.ms/vscodePythonTerminalActivation).',
     );
+    export const shellIntegrationEnvVarCollectionDescription = l10n.t(
+        'Enables `python.terminal.shellIntegration.enabled` by modifying `PYTHONSTARTUP` and `PYTHON_BASIC_REPL`',
+    );
+    export const shellIntegrationDisabledEnvVarCollectionDescription = l10n.t(
+        'Disables `python.terminal.shellIntegration.enabled` by unsetting `PYTHONSTARTUP` and `PYTHON_BASIC_REPL`',
+    );
     export const terminalDeactivateProgress = l10n.t('Editing {0}...');
     export const restartingTerminal = l10n.t('Restarting terminal and deactivating...');
     export const terminalDeactivatePrompt = l10n.t(
@@ -257,7 +281,6 @@ export namespace InterpreterQuickPickList {
 export namespace OutputChannelNames {
     export const languageServer = l10n.t('Python Language Server');
     export const python = l10n.t('Python');
-    export const pythonTest = l10n.t('Python Test Log');
 }
 
 export namespace Linters {
@@ -412,7 +435,6 @@ export namespace DebugConfigStrings {
 
 export namespace Testing {
     export const configureTests = l10n.t('Configure Test Framework');
-    export const testNotConfigured = l10n.t('No test framework configured.');
     export const cancelUnittestDiscovery = l10n.t('Canceled unittest test discovery');
     export const errorUnittestDiscovery = l10n.t('Unittest test discovery error');
     export const cancelPytestDiscovery = l10n.t('Canceled pytest test discovery');
@@ -518,3 +540,15 @@ export namespace CreateEnv {
         );
     }
 }
+
+export namespace PythonLocator {
+    export const startupFailedNotification = l10n.t(
+        'Python Locator failed to start. Python environment discovery may not work correctly.',
+    );
+    export const windowsRuntimeMissing = l10n.t(
+        'Missing Windows runtime dependencies detected. The Python Locator requires the Microsoft Visual C++ Redistributable. This is often missing on clean Windows installations.',
+    );
+    export const windowsStartupFailed = l10n.t(
+        'Python Locator failed to start on Windows. This might be due to missing system dependencies such as the Microsoft Visual C++ Redistributable.',
+    );
+}
diff --git a/src/client/common/vscodeApis/commandApis.ts b/src/client/common/vscodeApis/commandApis.ts
index 580760e106e1..908cb761c538 100644
--- a/src/client/common/vscodeApis/commandApis.ts
+++ b/src/client/common/vscodeApis/commandApis.ts
@@ -3,13 +3,16 @@
 
 import { commands, Disposable } from 'vscode';
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/**
+ * Wrapper for vscode.commands.executeCommand to make it easier to mock in tests
+ */
+export function executeCommand<T>(command: string, ...rest: any[]): Thenable<T> {
+    return commands.executeCommand<T>(command, ...rest);
+}
 
+/**
+ * Wrapper for vscode.commands.registerCommand to make it easier to mock in tests
+ */
 export function registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): Disposable {
     return commands.registerCommand(command, callback, thisArg);
 }
-
-export function executeCommand<T = unknown>(command: string, ...rest: any[]): Thenable<T> {
-    return commands.executeCommand(command, ...rest);
-}
diff --git a/src/client/common/vscodeApis/windowApis.ts b/src/client/common/vscodeApis/windowApis.ts
index fc63a189f2ff..90a06e7ed75a 100644
--- a/src/client/common/vscodeApis/windowApis.ts
+++ b/src/client/common/vscodeApis/windowApis.ts
@@ -22,6 +22,10 @@ import {
     LogOutputChannel,
     OutputChannel,
     TerminalLinkProvider,
+    NotebookDocument,
+    NotebookEditor,
+    NotebookDocumentShowOptions,
+    Terminal,
 } from 'vscode';
 import { createDeferred, Deferred } from '../utils/async';
 import { Resource } from '../types';
@@ -31,6 +35,13 @@ export function showTextDocument(uri: Uri): Thenable<TextEditor> {
     return window.showTextDocument(uri);
 }
 
+export function showNotebookDocument(
+    document: NotebookDocument,
+    options?: NotebookDocumentShowOptions,
+): Thenable<NotebookEditor> {
+    return window.showNotebookDocument(document, options);
+}
+
 export function showQuickPick<T extends QuickPickItem>(
     items: readonly T[] | Thenable<readonly T[]>,
     options?: QuickPickOptions,
@@ -114,6 +125,10 @@ export function onDidStartTerminalShellExecution(handler: (e: TerminalShellExecu
     return window.onDidStartTerminalShellExecution(handler);
 }
 
+export function onDidChangeTerminalState(handler: (e: Terminal) => void): Disposable {
+    return window.onDidChangeTerminalState(handler);
+}
+
 export enum MultiStepAction {
     Back = 'Back',
     Cancel = 'Cancel',
diff --git a/src/client/common/vscodeApis/workspaceApis.ts b/src/client/common/vscodeApis/workspaceApis.ts
index cb516da73075..cd45f655702d 100644
--- a/src/client/common/vscodeApis/workspaceApis.ts
+++ b/src/client/common/vscodeApis/workspaceApis.ts
@@ -60,6 +60,10 @@ export function onDidChangeConfiguration(handler: (e: vscode.ConfigurationChange
     return vscode.workspace.onDidChangeConfiguration(handler);
 }
 
+export function onDidCloseNotebookDocument(handler: (e: vscode.NotebookDocument) => void): vscode.Disposable {
+    return vscode.workspace.onDidCloseNotebookDocument(handler);
+}
+
 export function createFileSystemWatcher(
     globPattern: vscode.GlobPattern,
     ignoreCreateEvents?: boolean,
@@ -98,6 +102,15 @@ export function createDirectory(uri: vscode.Uri): Thenable<void> {
     return vscode.workspace.fs.createDirectory(uri);
 }
 
+export function openNotebookDocument(uri: vscode.Uri): Thenable<vscode.NotebookDocument>;
+export function openNotebookDocument(
+    notebookType: string,
+    content?: vscode.NotebookData,
+): Thenable<vscode.NotebookDocument>;
+export function openNotebookDocument(notebook: any, content?: vscode.NotebookData): Thenable<vscode.NotebookDocument> {
+    return vscode.workspace.openNotebookDocument(notebook, content);
+}
+
 export function copy(source: vscode.Uri, dest: vscode.Uri, options?: { overwrite?: boolean }): Thenable<void> {
     return vscode.workspace.fs.copy(source, dest, options);
 }
diff --git a/src/client/envExt/api.internal.ts b/src/client/envExt/api.internal.ts
index 7d511eac49ea..5edfb712072e 100644
--- a/src/client/envExt/api.internal.ts
+++ b/src/client/envExt/api.internal.ts
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { EventEmitter, Terminal, Uri, Disposable, ConfigurationTarget } from 'vscode';
+import { EventEmitter, Terminal, Uri, Disposable } from 'vscode';
 import { getExtension } from '../common/vscodeApis/extensionsApi';
 import {
     GetEnvironmentScope,
@@ -13,16 +13,56 @@ import {
     DidChangeEnvironmentEventArgs,
 } from './types';
 import { executeCommand } from '../common/vscodeApis/commandApis';
-import { IInterpreterPathService } from '../common/types';
+import { getConfiguration, getWorkspaceFolders } from '../common/vscodeApis/workspaceApis';
+import { traceError, traceLog } from '../logging';
+import { Interpreters } from '../common/utils/localize';
 
 export const ENVS_EXTENSION_ID = 'ms-python.vscode-python-envs';
 
+export function isEnvExtensionInstalled(): boolean {
+    return !!getExtension(ENVS_EXTENSION_ID);
+}
+
+/**
+ * Returns true if the Python Environments extension is installed and not explicitly
+ * disabled by the user. Mirrors the envs extension's own activation logic: it
+ * deactivates only when `python.useEnvironmentsExtension` is explicitly set to false
+ * at the global, workspace, or workspace-folder level.
+ */
+export function shouldEnvExtHandleActivation(): boolean {
+    if (!isEnvExtensionInstalled()) {
+        return false;
+    }
+    const config = getConfiguration('python');
+    const inspection = config.inspect<boolean>('useEnvironmentsExtension');
+    if (inspection?.globalValue === false || inspection?.workspaceValue === false) {
+        return false;
+    }
+    // The envs extension also checks folder-scoped settings in multi-root workspaces.
+    // Any single folder with the setting set to false causes the envs extension to
+    // deactivate entirely (window-wide), so we must mirror that here.
+    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) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 let _useExt: boolean | undefined;
 export function useEnvExtension(): boolean {
     if (_useExt !== undefined) {
         return _useExt;
     }
-    _useExt = !!getExtension(ENVS_EXTENSION_ID);
+    const config = getConfiguration('python');
+    const inExpSetting = config?.get<boolean>('useEnvironmentsExtension', false) ?? false;
+    // If extension is installed and in experiment, then use it.
+    _useExt = !!getExtension(ENVS_EXTENSION_ID) && inExpSetting;
     return _useExt;
 }
 
@@ -44,12 +84,20 @@ export async function getEnvExtApi(): Promise<PythonEnvironmentApi> {
     }
     const extension = getExtension(ENVS_EXTENSION_ID);
     if (!extension) {
+        traceError(Interpreters.envExtActivationFailed);
         throw new Error('Python Environments extension not found.');
     }
     if (!extension?.isActive) {
-        await extension.activate();
+        try {
+            await extension.activate();
+        } catch (ex) {
+            traceError(Interpreters.envExtActivationFailed, ex);
+            throw ex;
+        }
     }
 
+    traceLog(Interpreters.envExtDiscoveryAttribution);
+
     _extApi = extension.exports as PythonEnvironmentApi;
     _extApi.onDidChangeEnvironment((e) => {
         onDidChangeEnvironmentEnvExtEmitter.fire(e);
@@ -68,7 +116,16 @@ export async function runInBackground(
 
 export async function getEnvironment(scope: GetEnvironmentScope): Promise<PythonEnvironment | undefined> {
     const envExtApi = await getEnvExtApi();
-    return envExtApi.getEnvironment(scope);
+    const env = await envExtApi.getEnvironment(scope);
+    if (!env) {
+        traceLog(Interpreters.envExtNoActiveEnvironment);
+    }
+    return env;
+}
+
+export async function resolveEnvironment(pythonPath: string): Promise<PythonEnvironment | undefined> {
+    const envExtApi = await getEnvExtApi();
+    return envExtApi.resolveEnvironment(Uri.file(pythonPath));
 }
 
 export async function refreshEnvironments(scope: RefreshEnvironmentsScope): Promise<void> {
@@ -120,32 +177,3 @@ export async function clearCache(): Promise<void> {
         await executeCommand('python-envs.clearCache');
     }
 }
-
-export function registerEnvExtFeatures(
-    disposables: Disposable[],
-    interpreterPathService: IInterpreterPathService,
-): void {
-    if (useEnvExtension()) {
-        disposables.push(
-            onDidChangeEnvironmentEnvExt(async (e: DidChangeEnvironmentEventArgs) => {
-                const previousPath = interpreterPathService.get(e.uri);
-
-                if (previousPath !== e.new?.environmentPath.fsPath) {
-                    if (e.uri) {
-                        await interpreterPathService.update(
-                            e.uri,
-                            ConfigurationTarget.WorkspaceFolder,
-                            e.new?.environmentPath.fsPath,
-                        );
-                    } else {
-                        await interpreterPathService.update(
-                            undefined,
-                            ConfigurationTarget.Global,
-                            e.new?.environmentPath.fsPath,
-                        );
-                    }
-                }
-            }),
-        );
-    }
-}
diff --git a/src/client/envExt/api.legacy.ts b/src/client/envExt/api.legacy.ts
index 7546a429c76a..6f2e60774033 100644
--- a/src/client/envExt/api.legacy.ts
+++ b/src/client/envExt/api.legacy.ts
@@ -1,14 +1,14 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { Terminal, Uri, WorkspaceFolder } from 'vscode';
+import { Terminal, Uri } from 'vscode';
 import { getEnvExtApi, getEnvironment } from './api.internal';
 import { EnvironmentType, PythonEnvironment as PythonEnvironmentLegacy } from '../pythonEnvironments/info';
-import { PythonEnvironment, PythonTerminalOptions } from './types';
+import { PythonEnvironment, PythonTerminalCreateOptions } from './types';
 import { Architecture } from '../common/utils/platform';
 import { parseVersion } from '../pythonEnvironments/base/info/pythonVersion';
 import { PythonEnvType } from '../pythonEnvironments/base/info';
-import { traceError, traceInfo } from '../logging';
+import { traceError } from '../logging';
 import { reportActiveInterpreterChanged } from '../environmentApi';
 import { getWorkspaceFolder, getWorkspaceFolders } from '../common/vscodeApis/workspaceApis';
 
@@ -77,13 +77,13 @@ function toLegacyType(env: PythonEnvironment): PythonEnvironmentLegacy {
     const ver = parseVersion(env.version);
     const envType = toEnvironmentType(env);
     return {
-        id: env.environmentPath.fsPath,
+        id: env.execInfo.run.executable,
         displayName: env.displayName,
         detailedDisplayName: env.name,
         envType,
         envPath: env.sysPrefix,
         type: getEnvType(envType),
-        path: env.environmentPath.fsPath,
+        path: env.execInfo.run.executable,
         version: {
             raw: env.version,
             major: ver.major,
@@ -120,36 +120,6 @@ export async function getActiveInterpreterLegacy(resource?: Uri): Promise<Python
     return pythonEnv ? toLegacyType(pythonEnv) : undefined;
 }
 
-export async function ensureEnvironmentContainsPythonLegacy(
-    pythonPath: string,
-    workspaceFolder: WorkspaceFolder | undefined,
-    callback: () => void,
-): Promise<void> {
-    const api = await getEnvExtApi();
-    const pythonEnv = await api.resolveEnvironment(Uri.file(pythonPath));
-    if (!pythonEnv) {
-        traceError(`EnvExt: Failed to resolve environment for ${pythonPath}`);
-        return;
-    }
-
-    const envType = toEnvironmentType(pythonEnv);
-    if (envType === EnvironmentType.Conda) {
-        const packages = await api.getPackages(pythonEnv);
-        if (packages && packages.length > 0 && packages.some((pkg) => pkg.name.toLowerCase() === 'python')) {
-            return;
-        }
-        traceInfo(`EnvExt: Python not found in ${envType} environment ${pythonPath}`);
-        traceInfo(`EnvExt: Installing Python in ${envType} environment ${pythonPath}`);
-        await api.installPackages(pythonEnv, ['python']);
-        previousEnvMap.set(workspaceFolder?.uri.fsPath || '', pythonEnv);
-        reportActiveInterpreterChanged({
-            path: pythonPath,
-            resource: workspaceFolder,
-        });
-        callback();
-    }
-}
-
 export async function setInterpreterLegacy(pythonPath: string, uri: Uri | undefined): Promise<void> {
     const api = await getEnvExtApi();
     const pythonEnv = await api.resolveEnvironment(Uri.file(pythonPath));
@@ -167,7 +137,7 @@ export async function resetInterpreterLegacy(uri: Uri | undefined): Promise<void
 
 export async function ensureTerminalLegacy(
     resource: Uri | undefined,
-    options?: PythonTerminalOptions,
+    options?: PythonTerminalCreateOptions,
 ): Promise<Terminal> {
     const api = await getEnvExtApi();
     const pythonEnv = await api.getEnvironment(resource);
@@ -178,5 +148,24 @@ export async function ensureTerminalLegacy(
         const terminal = await api.createTerminal(pythonEnv, fixedOptions);
         return terminal;
     }
+    traceError('ensureTerminalLegacy - Did not return terminal successfully.');
+    traceError(
+        'ensureTerminalLegacy - pythonEnv:',
+        pythonEnv
+            ? `id=${pythonEnv.envId.id}, managerId=${pythonEnv.envId.managerId}, name=${pythonEnv.name}, version=${pythonEnv.version}, executable=${pythonEnv.execInfo.run.executable}`
+            : 'undefined',
+    );
+    traceError(
+        'ensureTerminalLegacy - project:',
+        project ? `name=${project.name}, uri=${project.uri.toString()}` : 'undefined',
+    );
+    traceError(
+        'ensureTerminalLegacy - options:',
+        options
+            ? `name=${options.name}, cwd=${options.cwd?.toString()}, hideFromUser=${options.hideFromUser}`
+            : 'undefined',
+    );
+    traceError('ensureTerminalLegacy - resource:', resource?.toString() || 'undefined');
+
     throw new Error('Invalid arguments to create terminal');
 }
diff --git a/src/client/envExt/envExtApi.ts b/src/client/envExt/envExtApi.ts
index 598899b7d248..34f42f0d6954 100644
--- a/src/client/envExt/envExtApi.ts
+++ b/src/client/envExt/envExtApi.ts
@@ -17,7 +17,7 @@ import { PythonEnvCollectionChangedEvent } from '../pythonEnvironments/base/watc
 import { getEnvExtApi } from './api.internal';
 import { createDeferred, Deferred } from '../common/utils/async';
 import { StopWatch } from '../common/utils/stopWatch';
-import { traceLog } from '../logging';
+import { traceError, traceLog, traceWarn } from '../logging';
 import {
     DidChangeEnvironmentsEventArgs,
     EnvironmentChangeKind,
@@ -27,6 +27,7 @@ import {
 import { FileChangeType } from '../common/platform/fileSystemWatcher';
 import { Architecture, isWindows } from '../common/utils/platform';
 import { parseVersion } from '../pythonEnvironments/base/info/pythonVersion';
+import { Interpreters } from '../common/utils/localize';
 
 function getKind(pythonEnv: PythonEnvironment): PythonEnvKind {
     if (pythonEnv.envId.managerId.toLowerCase().endsWith('system')) {
@@ -242,13 +243,23 @@ class EnvExtApis implements IDiscoveryAPI, Disposable {
         this._onProgress.fire({ stage: this.refreshState });
         this._refreshPromise = createDeferred();
 
+        const SLOW_DISCOVERY_THRESHOLD_MS = 25_000;
+        const slowDiscoveryTimer = setTimeout(() => {
+            traceWarn(Interpreters.envExtDiscoverySlow);
+        }, SLOW_DISCOVERY_THRESHOLD_MS);
+
         setImmediate(async () => {
             try {
                 await this.envExtApi.refreshEnvironments(undefined);
+                if (this._envs.length === 0) {
+                    traceWarn(Interpreters.envExtDiscoveryNoEnvironments);
+                }
                 this._refreshPromise?.resolve();
             } catch (error) {
+                traceError(Interpreters.envExtDiscoveryFailed, error);
                 this._refreshPromise?.reject(error);
             } finally {
+                clearTimeout(slowDiscoveryTimer);
                 traceLog(`Native locator: Refresh finished in ${stopwatch.elapsedTime} ms`);
                 this.refreshState = ProgressReportStage.discoveryFinished;
                 this._refreshPromise = undefined;
@@ -297,9 +308,16 @@ class EnvExtApis implements IDiscoveryAPI, Disposable {
         if (envPath === undefined) {
             return undefined;
         }
-        const pythonEnv = await this.envExtApi.resolveEnvironment(Uri.file(envPath));
-        if (pythonEnv) {
-            return this.addEnv(pythonEnv);
+        try {
+            const pythonEnv = await this.envExtApi.resolveEnvironment(Uri.file(envPath));
+            if (pythonEnv) {
+                return this.addEnv(pythonEnv);
+            }
+        } catch (error) {
+            traceError(
+                `Failed to resolve environment "${envPath}" via the Python Environments extension (ms-python.vscode-python-envs). Check the "Python Environments" output channel for details.`,
+                error,
+            );
         }
         return undefined;
     }
diff --git a/src/client/envExt/types.ts b/src/client/envExt/types.ts
index 190c0ccea5b9..707d641bbfe8 100644
--- a/src/client/envExt/types.ts
+++ b/src/client/envExt/types.ts
@@ -2,16 +2,16 @@
 // Licensed under the MIT License.
 
 import {
-    Uri,
     Disposable,
-    MarkdownString,
     Event,
+    FileChangeType,
     LogOutputChannel,
-    ThemeIcon,
-    Terminal,
+    MarkdownString,
     TaskExecution,
+    Terminal,
     TerminalOptions,
-    FileChangeType,
+    ThemeIcon,
+    Uri,
 } from 'vscode';
 
 /**
@@ -48,23 +48,6 @@ export interface PythonCommandRunConfiguration {
     args?: string[];
 }
 
-export enum TerminalShellType {
-    powershell = 'powershell',
-    powershellCore = 'powershellCore',
-    commandPrompt = 'commandPrompt',
-    gitbash = 'gitbash',
-    bash = 'bash',
-    zsh = 'zsh',
-    ksh = 'ksh',
-    fish = 'fish',
-    cshell = 'cshell',
-    tcshell = 'tshell',
-    nushell = 'nushell',
-    wsl = 'wsl',
-    xonsh = 'xonsh',
-    unknown = 'unknown',
-}
-
 /**
  * Contains details on how to use a particular python environment
  *
@@ -73,7 +56,7 @@ export enum TerminalShellType {
  * 2. If {@link PythonEnvironmentExecutionInfo.activatedRun} is not provided, then:
  *   - If {@link PythonEnvironmentExecutionInfo.shellActivation} is provided and shell type is known, then that will be used.
  *   - If {@link PythonEnvironmentExecutionInfo.shellActivation} is provided and shell type is not known, then:
- *     - {@link TerminalShellType.unknown} will be used if provided.
+ *     - 'unknown' will be used if provided.
  *     - {@link PythonEnvironmentExecutionInfo.activation} will be used otherwise.
  *   - If {@link PythonEnvironmentExecutionInfo.shellActivation} is not provided, then {@link PythonEnvironmentExecutionInfo.activation} will be used.
  *   - If {@link PythonEnvironmentExecutionInfo.activation} is not provided, then {@link PythonEnvironmentExecutionInfo.run} will be used.
@@ -82,7 +65,7 @@ export enum TerminalShellType {
  * 1. If {@link PythonEnvironmentExecutionInfo.shellActivation} is provided and shell type is known, then that will be used.
  * 2. If {@link PythonEnvironmentExecutionInfo.shellActivation} is provided and shell type is not known, then {@link PythonEnvironmentExecutionInfo.activation} will be used.
  * 3. If {@link PythonEnvironmentExecutionInfo.shellActivation} is not provided, then:
- *     - {@link TerminalShellType.unknown} will be used if provided.
+ *     - 'unknown' will be used if provided.
  *     - {@link PythonEnvironmentExecutionInfo.activation} will be used otherwise.
  * 4. If {@link PythonEnvironmentExecutionInfo.activation} is not provided, then {@link PythonEnvironmentExecutionInfo.run} will be used.
  *
@@ -107,11 +90,11 @@ export interface PythonEnvironmentExecutionInfo {
     /**
      * Details on how to activate an environment using a shell specific command.
      * If set this will override the {@link PythonEnvironmentExecutionInfo.activation}.
-     * {@link TerminalShellType.unknown} is used if shell type is not known.
-     * If {@link TerminalShellType.unknown} is not provided and shell type is not known then
+     * 'unknown' is used if shell type is not known.
+     * If 'unknown' is not provided and shell type is not known then
      * {@link PythonEnvironmentExecutionInfo.activation} if set.
      */
-    shellActivation?: Map<TerminalShellType, PythonCommandRunConfiguration[]>;
+    shellActivation?: Map<string, PythonCommandRunConfiguration[]>;
 
     /**
      * Details on how to deactivate an environment.
@@ -121,11 +104,11 @@ export interface PythonEnvironmentExecutionInfo {
     /**
      * Details on how to deactivate an environment using a shell specific command.
      * If set this will override the {@link PythonEnvironmentExecutionInfo.deactivation} property.
-     * {@link TerminalShellType.unknown} is used if shell type is not known.
-     * If {@link TerminalShellType.unknown} is not provided and shell type is not known then
+     * 'unknown' is used if shell type is not known.
+     * If 'unknown' is not provided and shell type is not known then
      * {@link PythonEnvironmentExecutionInfo.deactivation} if set.
      */
-    shellDeactivation?: Map<TerminalShellType, PythonCommandRunConfiguration[]>;
+    shellDeactivation?: Map<string, PythonCommandRunConfiguration[]>;
 }
 
 /**
@@ -143,6 +126,33 @@ export interface PythonEnvironmentId {
     managerId: string;
 }
 
+/**
+ * Display information for an environment group.
+ */
+export interface EnvironmentGroupInfo {
+    /**
+     * The name of the environment group. This is used as an identifier for the group.
+     *
+     * Note: The first instance of the group with the given name will be used in the UI.
+     */
+    readonly name: string;
+
+    /**
+     * The description of the environment group.
+     */
+    readonly description?: string;
+
+    /**
+     * The tooltip for the environment group, which can be a string or a Markdown string.
+     */
+    readonly tooltip?: string | MarkdownString;
+
+    /**
+     * The icon path for the environment group, which can be a string, Uri, or an object with light and dark theme paths.
+     */
+    readonly iconPath?: IconPath;
+}
+
 /**
  * Interface representing information about a Python environment.
  */
@@ -193,16 +203,20 @@ export interface PythonEnvironmentInfo {
     readonly iconPath?: IconPath;
 
     /**
-     * Information on how to execute the Python environment. If not provided, {@link PythonEnvironmentApi.resolveEnvironment} will be
-     * used to to get the details at later point if needed. The recommendation is to fill this in if known.
+     * Information on how to execute the Python environment. This is required for executing Python code in the environment.
      */
-    readonly execInfo?: PythonEnvironmentExecutionInfo;
+    readonly execInfo: PythonEnvironmentExecutionInfo;
 
     /**
      * `sys.prefix` is the path to the base directory of the Python installation. Typically obtained by executing `sys.prefix` in the Python interpreter.
      * This is required by extension like Jupyter, Pylance, and other extensions to provide better experience with python.
      */
     readonly sysPrefix: string;
+
+    /**
+     * Optional `group` for this environment. This is used to group environments in the Environment Manager UI.
+     */
+    readonly group?: string | EnvironmentGroupInfo;
 }
 
 /**
@@ -219,7 +233,7 @@ export interface PythonEnvironment extends PythonEnvironmentInfo {
  * Type representing the scope for setting a Python environment.
  * Can be undefined or a URI.
  */
-export type SetEnvironmentScope = undefined | Uri;
+export type SetEnvironmentScope = undefined | Uri | Uri[];
 
 /**
  * Type representing the scope for getting a Python environment.
@@ -300,14 +314,26 @@ export type DidChangeEnvironmentsEventArgs = {
 /**
  * Type representing the context for resolving a Python environment.
  */
-export type ResolveEnvironmentContext = PythonEnvironment | Uri;
+export type ResolveEnvironmentContext = Uri;
+
+export interface QuickCreateConfig {
+    /**
+     * The description of the quick create step.
+     */
+    readonly description: string;
+
+    /**
+     * The detail of the quick create step.
+     */
+    readonly detail?: string;
+}
 
 /**
  * Interface representing an environment manager.
  */
 export interface EnvironmentManager {
     /**
-     * The name of the environment manager.
+     * The name of the environment manager. Allowed characters (a-z, A-Z, 0-9, -, _).
      */
     readonly name: string;
 
@@ -317,7 +343,9 @@ export interface EnvironmentManager {
     readonly displayName?: string;
 
     /**
-     * The preferred package manager ID for the environment manager.
+     * The preferred package manager ID for the environment manager. This is a combination
+     * of publisher id, extension id, and {@link EnvironmentManager.name package manager name}.
+     * `<publisher-id>.<extension-id>:<package-manager-name>`
      *
      * @example
      * 'ms-python.python:pip'
@@ -344,12 +372,19 @@ export interface EnvironmentManager {
      */
     readonly log?: LogOutputChannel;
 
+    /**
+     * The quick create details for the environment manager. Having this method also enables the quick create feature
+     * for the environment manager. Should Implement {@link EnvironmentManager.create} to support quick create.
+     */
+    quickCreateConfig?(): QuickCreateConfig | undefined;
+
     /**
      * Creates a new Python environment within the specified scope.
      * @param scope - The scope within which to create the environment.
+     * @param options - Optional parameters for creating the Python environment.
      * @returns A promise that resolves to the created Python environment, or undefined if creation failed.
      */
-    create?(scope: CreateEnvironmentScope): Promise<PythonEnvironment | undefined>;
+    create?(scope: CreateEnvironmentScope, options?: CreateEnvironmentOptions): Promise<PythonEnvironment | undefined>;
 
     /**
      * Removes the specified Python environment.
@@ -529,7 +564,7 @@ export interface DidChangePackagesEventArgs {
  */
 export interface PackageManager {
     /**
-     * The name of the package manager.
+     * The name of the package manager. Allowed characters (a-z, A-Z, 0-9, -, _).
      */
     name: string;
 
@@ -559,20 +594,12 @@ export interface PackageManager {
     log?: LogOutputChannel;
 
     /**
-     * Installs packages in the specified Python environment.
+     * Installs/Uninstall packages in the specified Python environment.
      * @param environment - The Python environment in which to install packages.
-     * @param packages - The packages to install.
+     * @param options - Options for managing packages.
      * @returns A promise that resolves when the installation is complete.
      */
-    install(environment: PythonEnvironment, packages: string[], options: PackageInstallOptions): Promise<void>;
-
-    /**
-     * Uninstalls packages from the specified Python environment.
-     * @param environment - The Python environment from which to uninstall packages.
-     * @param packages - The packages to uninstall, which can be an array of packages or strings.
-     * @returns A promise that resolves when the uninstall is complete.
-     */
-    uninstall(environment: PythonEnvironment, packages: Package[] | string[]): Promise<void>;
+    manage(environment: PythonEnvironment, options: PackageManagementOptions): Promise<void>;
 
     /**
      * Refreshes the package list for the specified Python environment.
@@ -588,17 +615,6 @@ export interface PackageManager {
      */
     getPackages(environment: PythonEnvironment): Promise<Package[] | undefined>;
 
-    /**
-     * Get a list of installable items for a Python project.
-     *
-     * @param environment The Python environment for which to get installable items.
-     *
-     * Note: An environment can be used by multiple projects, so the installable items returned.
-     * should be for the environment. If you want to do it for a particular project, then you should
-     * ask user to select a project, and filter the installable items based on the project.
-     */
-    getInstallable?(environment: PythonEnvironment): Promise<Installable[]>;
-
     /**
      * Event that is fired when packages change.
      */
@@ -651,9 +667,14 @@ export interface PythonProjectCreatorOptions {
     name: string;
 
     /**
-     * Optional path that may be provided as a root for the project.
+     * Path provided as the root for the project.
      */
-    uri?: Uri;
+    rootUri: Uri;
+
+    /**
+     * Boolean indicating whether the project should be created without any user input.
+     */
+    quickCreate?: boolean;
 }
 
 /**
@@ -686,11 +707,20 @@ export interface PythonProjectCreator {
     readonly iconPath?: IconPath;
 
     /**
-     * Creates a new Python project or projects.
-     * @param options - Optional parameters for creating the Python project.
-     * @returns A promise that resolves to a Python project, an array of Python projects, or undefined.
+     * Creates a new Python project(s) or, if files are not a project, returns Uri(s) to the created files.
+     * Anything that needs its own python environment constitutes a project.
+     * @param options Optional parameters for creating the Python project.
+     * @returns A promise that resolves to one of the following:
+     *   - PythonProject or PythonProject[]: when a single or multiple projects are created.
+     *   - Uri or Uri[]: when files are created that do not constitute a project.
+     *   - undefined: if project creation fails.
      */
-    create(options?: PythonProjectCreatorOptions): Promise<PythonProject | PythonProject[] | undefined>;
+    create(options?: PythonProjectCreatorOptions): Promise<PythonProject | PythonProject[] | Uri | Uri[] | undefined>;
+
+    /**
+     * A flag indicating whether the project creator supports quick create where no user input is required.
+     */
+    readonly supportsQuickCreate?: boolean;
 }
 
 /**
@@ -708,55 +738,70 @@ export interface DidChangePythonProjectsEventArgs {
     removed: PythonProject[];
 }
 
-/**
- * Options for package installation.
- */
-export interface PackageInstallOptions {
-    /**
-     * Upgrade the packages if it is already installed.
-     */
-    upgrade?: boolean;
-}
+export type PackageManagementOptions =
+    | {
+          /**
+           * Upgrade the packages if they are already installed.
+           */
+          upgrade?: boolean;
 
-export interface Installable {
-    /**
-     * The display name of the package, requirements, pyproject.toml or any other project file.
-     */
-    readonly displayName: string;
+          /**
+           * Show option to skip package installation or uninstallation.
+           */
+          showSkipOption?: boolean;
+          /**
+           * The list of packages to install.
+           */
+          install: string[];
 
-    /**
-     * Arguments passed to the package manager to install the package.
-     *
-     * @example
-     *  ['debugpy==1.8.7'] for `pip install debugpy==1.8.7`.
-     *  ['--pre', 'debugpy'] for `pip install --pre debugpy`.
-     *  ['-r', 'requirements.txt'] for `pip install -r requirements.txt`.
-     */
-    readonly args: string[];
+          /**
+           * The list of packages to uninstall.
+           */
+          uninstall?: string[];
+      }
+    | {
+          /**
+           * Upgrade the packages if they are already installed.
+           */
+          upgrade?: boolean;
 
-    /**
-     * Installable group name, this will be used to group installable items in the UI.
-     *
-     * @example
-     *  `Requirements` for any requirements file.
-     *  `Packages` for any package.
-     */
-    readonly group?: string;
+          /**
+           * Show option to skip package installation or uninstallation.
+           */
+          showSkipOption?: boolean;
+          /**
+           * The list of packages to install.
+           */
+          install?: string[];
+
+          /**
+           * The list of packages to uninstall.
+           */
+          uninstall: string[];
+      };
 
+/**
+ * Options for creating a Python environment.
+ */
+export interface CreateEnvironmentOptions {
     /**
-     * Description about the installable item. This can also be path to the requirements,
-     * version of the package, or any other project file path.
+     * Provides some context about quick create based on user input.
+     *   - if true, the environment should be created without any user input or prompts.
+     *   - if false, the environment creation can show user input or prompts.
+     *     This also means user explicitly skipped the quick create option.
+     *   - if undefined, the environment creation can show user input or prompts.
+     *     You can show quick create option to the user if you support it.
      */
-    readonly description?: string;
-
+    quickCreate?: boolean;
     /**
-     * External Uri to the package on pypi or docs.
-     * @example
-     *  https://pypi.org/project/debugpy/ for `debugpy`.
+     * Packages to install in addition to the automatically picked packages as a part of creating environment.
      */
-    readonly uri?: Uri;
+    additionalPackages?: string[];
 }
 
+/**
+ * Object representing the process started using run in background API.
+ */
 export interface PythonProcess {
     /**
      * The process ID of the Python process.
@@ -817,9 +862,13 @@ export interface PythonEnvironmentManagementApi {
      * Create a Python environment using environment manager associated with the scope.
      *
      * @param scope Where the environment is to be created.
+     * @param options Optional parameters for creating the Python environment.
      * @returns The Python environment created. `undefined` if not created.
      */
-    createEnvironment(scope: CreateEnvironmentScope): Promise<PythonEnvironment | undefined>;
+    createEnvironment(
+        scope: CreateEnvironmentScope,
+        options?: CreateEnvironmentOptions,
+    ): Promise<PythonEnvironment | undefined>;
 
     /**
      * Remove a Python environment.
@@ -938,21 +987,13 @@ export interface PythonPackageItemApi {
 
 export interface PythonPackageManagementApi {
     /**
-     * Install packages into a Python Environment.
+     * Install/Uninstall packages into a Python Environment.
      *
      * @param environment The Python Environment into which packages are to be installed.
      * @param packages The packages to install.
      * @param options Options for installing packages.
      */
-    installPackages(environment: PythonEnvironment, packages: string[], options?: PackageInstallOptions): Promise<void>;
-
-    /**
-     * Uninstall packages from a Python Environment.
-     *
-     * @param environment The Python Environment from which packages are to be uninstalled.
-     * @param packages The packages to uninstall.
-     */
-    uninstallPackages(environment: PythonEnvironment, packages: PackageInfo[] | string[]): Promise<void>;
+    managePackages(environment: PythonEnvironment, options: PackageManagementOptions): Promise<void>;
 }
 
 export interface PythonPackageManagerApi
@@ -1017,9 +1058,9 @@ export interface PythonProjectModifyApi {
  */
 export interface PythonProjectApi extends PythonProjectCreationApi, PythonProjectGetterApi, PythonProjectModifyApi {}
 
-export interface PythonTerminalOptions extends TerminalOptions {
+export interface PythonTerminalCreateOptions extends TerminalOptions {
     /**
-     * Whether to show the terminal.
+     * Whether to disable activation on create.
      */
     disableActivation?: boolean;
 }
@@ -1033,7 +1074,7 @@ export interface PythonTerminalCreateApi {
      *
      * Note: Non-activatable environments have no effect on the terminal.
      */
-    createTerminal(environment: PythonEnvironment, options: PythonTerminalOptions): Promise<Terminal>;
+    createTerminal(environment: PythonEnvironment, options: PythonTerminalCreateOptions): Promise<Terminal>;
 }
 
 /**
diff --git a/src/client/extension.ts b/src/client/extension.ts
index 521a8878ab63..c3fb2a3ab3b0 100644
--- a/src/client/extension.ts
+++ b/src/client/extension.ts
@@ -43,6 +43,10 @@ import { disposeAll } from './common/utils/resourceLifecycle';
 import { ProposedExtensionAPI } from './proposedApiTypes';
 import { buildProposedApi } from './proposedApi';
 import { GLOBAL_PERSISTENT_KEYS } from './common/persistentState';
+import { registerTools } from './chat';
+import { IRecommendedEnvironmentService } from './interpreter/configuration/types';
+import { registerTypes as unitTestsRegisterTypes } from './testing/serviceRegistry';
+import { registerTestCommands } from './testing/main';
 
 durations.codeLoadingTime = stopWatch.elapsedTime;
 
@@ -119,6 +123,11 @@ async function activateUnsafe(
     // Note standard utils especially experiment and platform code are fundamental to the extension
     // and should be available before we activate anything else.Hence register them first.
     initializeStandard(ext);
+
+    // Register test services and commands early to prevent race conditions.
+    unitTestsRegisterTypes(ext.legacyIOC.serviceManager);
+    registerTestCommands(activatedServiceContainer);
+
     // We need to activate experiments before initializing components as objects are created or not created based on experiments.
     const experimentService = activatedServiceContainer.get<IExperimentService>(IExperimentService);
     // This guarantees that all experiment information has loaded & all telemetry will contain experiment info.
@@ -162,6 +171,10 @@ async function activateUnsafe(
         components.pythonEnvs,
     );
     const proposedApi = buildProposedApi(components.pythonEnvs, ext.legacyIOC.serviceContainer);
+    registerTools(context, components.pythonEnvs, api.environments, ext.legacyIOC.serviceContainer);
+    ext.legacyIOC.serviceContainer
+        .get<IRecommendedEnvironmentService>(IRecommendedEnvironmentService)
+        .registerEnvApi(api.environments);
     return [{ ...api, ...proposedApi }, activationPromise, ext.legacyIOC.serviceContainer];
 }
 
diff --git a/src/client/extensionActivation.ts b/src/client/extensionActivation.ts
index 362fcf8468ad..57bcb8237eeb 100644
--- a/src/client/extensionActivation.ts
+++ b/src/client/extensionActivation.ts
@@ -13,14 +13,7 @@ import { IApplicationEnvironment, ICommandManager, IWorkspaceService } from './c
 import { Commands, PYTHON_LANGUAGE, UseProposedApi } from './common/constants';
 import { registerTypes as installerRegisterTypes } from './common/installer/serviceRegistry';
 import { IFileSystem } from './common/platform/types';
-import {
-    IConfigurationService,
-    IDisposableRegistry,
-    IExtensions,
-    IInterpreterPathService,
-    ILogOutputChannel,
-    IPathUtils,
-} from './common/types';
+import { IConfigurationService, IDisposableRegistry, IExtensions, ILogOutputChannel, IPathUtils } from './common/types';
 import { noop } from './common/utils/misc';
 import { registerTypes as debugConfigurationRegisterTypes } from './debugger/extension/serviceRegistry';
 import { IDebugConfigurationService } from './debugger/extension/types';
@@ -33,7 +26,6 @@ import { setExtensionInstallTelemetryProperties } from './telemetry/extensionIns
 import { registerTypes as tensorBoardRegisterTypes } from './tensorBoard/serviceRegistry';
 import { registerTypes as commonRegisterTerminalTypes } from './terminals/serviceRegistry';
 import { ICodeExecutionHelper, ICodeExecutionManager, ITerminalAutoActivation } from './terminals/types';
-import { registerTypes as unitTestsRegisterTypes } from './testing/serviceRegistry';
 
 // components
 import * as pythonEnvironments from './pythonEnvironments';
@@ -45,7 +37,7 @@ import { DebugService } from './common/application/debugService';
 import { DebugSessionEventDispatcher } from './debugger/extension/hooks/eventHandlerDispatcher';
 import { IDebugSessionEventHandlers } from './debugger/extension/hooks/types';
 import { WorkspaceService } from './common/application/workspace';
-import { IInterpreterQuickPick } from './interpreter/configuration/types';
+import { IInterpreterQuickPick, IPythonPathUpdaterServiceManager } from './interpreter/configuration/types';
 import { registerAllCreateEnvironmentFeatures } from './pythonEnvironments/creation/registrations';
 import { registerCreateEnvironmentTriggers } from './pythonEnvironments/creation/createEnvironmentTrigger';
 import { initializePersistentStateForTriggers } from './common/persistentState';
@@ -56,7 +48,6 @@ import { registerTriggerForTerminalREPL } from './terminals/codeExecution/termin
 import { registerPythonStartup } from './terminals/pythonStartup';
 import { registerPixiFeatures } from './pythonEnvironments/common/environmentManagers/pixi';
 import { registerCustomTerminalLinkProvider } from './terminals/pythonStartupLinkProvider';
-import { registerEnvExtFeatures } from './envExt/api.internal';
 
 export async function activateComponents(
     // `ext` is passed to any extra activation funcs.
@@ -96,19 +87,15 @@ export function activateFeatures(ext: ExtensionState, _components: Components):
     const interpreterQuickPick: IInterpreterQuickPick = ext.legacyIOC.serviceContainer.get<IInterpreterQuickPick>(
         IInterpreterQuickPick,
     );
-    const interpreterPathService: IInterpreterPathService = ext.legacyIOC.serviceContainer.get<IInterpreterPathService>(
-        IInterpreterPathService,
-    );
     const interpreterService: IInterpreterService = ext.legacyIOC.serviceContainer.get<IInterpreterService>(
         IInterpreterService,
     );
-    registerEnvExtFeatures(ext.disposables, interpreterPathService);
     const pathUtils = ext.legacyIOC.serviceContainer.get<IPathUtils>(IPathUtils);
     registerPixiFeatures(ext.disposables);
     registerAllCreateEnvironmentFeatures(
         ext.disposables,
         interpreterQuickPick,
-        interpreterPathService,
+        ext.legacyIOC.serviceContainer.get<IPythonPathUpdaterServiceManager>(IPythonPathUpdaterServiceManager),
         interpreterService,
         pathUtils,
     );
@@ -144,7 +131,6 @@ async function activateLegacy(ext: ExtensionState, startupStopWatch: StopWatch):
     const { enableProposedApi } = applicationEnv.packageJson;
     serviceManager.addSingletonInstance<boolean>(UseProposedApi, enableProposedApi);
     // Feature specific registrations.
-    unitTestsRegisterTypes(serviceManager);
     installerRegisterTypes(serviceManager);
     commonRegisterTerminalTypes(serviceManager);
     debugConfigurationRegisterTypes(serviceManager);
diff --git a/src/client/extensionInit.ts b/src/client/extensionInit.ts
index 1332dc6bd070..b161643d2d97 100644
--- a/src/client/extensionInit.ts
+++ b/src/client/extensionInit.ts
@@ -4,7 +4,7 @@
 'use strict';
 
 import { Container } from 'inversify';
-import { Disposable, l10n, Memento, window } from 'vscode';
+import { Disposable, Memento, window } from 'vscode';
 import { registerTypes as platformRegisterTypes } from './common/platform/serviceRegistry';
 import { registerTypes as processRegisterTypes } from './common/process/serviceRegistry';
 import { registerTypes as commonRegisterTypes } from './common/serviceRegistry';
@@ -15,7 +15,6 @@ import {
     IExtensionContext,
     IMemento,
     ILogOutputChannel,
-    ITestOutputChannel,
     WORKSPACE_MEMENTO,
 } from './common/types';
 import { registerTypes as variableRegisterTypes } from './common/variables/serviceRegistry';
@@ -28,7 +27,6 @@ import * as pythonEnvironments from './pythonEnvironments';
 import { IDiscoveryAPI } from './pythonEnvironments/base/locator';
 import { registerLogger } from './logging';
 import { OutputChannelLogger } from './logging/outputChannelLogger';
-import { isTrusted, isVirtualWorkspace } from './common/vscodeApis/workspaceApis';
 
 // The code in this module should do nothing more complex than register
 // objects to DI and simple init (e.g. no side effects).  That implies
@@ -56,14 +54,7 @@ export function initializeGlobals(
     disposables.push(standardOutputChannel);
     disposables.push(registerLogger(new OutputChannelLogger(standardOutputChannel)));
 
-    const unitTestOutChannel = window.createOutputChannel(OutputChannelNames.pythonTest);
-    disposables.push(unitTestOutChannel);
-    if (isVirtualWorkspace() || !isTrusted()) {
-        unitTestOutChannel.appendLine(l10n.t('Unit tests are not supported in this environment.'));
-    }
-
     serviceManager.addSingletonInstance<ILogOutputChannel>(ILogOutputChannel, standardOutputChannel);
-    serviceManager.addSingletonInstance<ITestOutputChannel>(ITestOutputChannel, unitTestOutChannel);
 
     return {
         context,
diff --git a/src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts b/src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts
index 27816ee83296..a629d1bc793c 100644
--- a/src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts
+++ b/src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts
@@ -49,6 +49,7 @@ import { BaseInterpreterSelectorCommand } from './base';
 import { untildify } from '../../../../common/helpers';
 import { useEnvExtension } from '../../../../envExt/api.internal';
 import { setInterpreterLegacy } from '../../../../envExt/api.legacy';
+import { CreateEnvironmentResult } from '../../../../pythonEnvironments/creation/proposed.createEnvApis';
 
 export type InterpreterStateArgs = { path?: string; workspace: Resource };
 export type QuickPickType = IInterpreterQuickPickItem | ISpecialQuickPickItem | QuickPickItem;
@@ -229,12 +230,13 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
             sendTelemetryEvent(EventName.SELECT_INTERPRETER_ENTER_OR_FIND);
             return this._enterOrBrowseInterpreterPath.bind(this);
         } else if (selection.label === this.createEnvironmentSuggestion.label) {
-            this.commandManager
-                .executeCommand(Commands.Create_Environment, {
+            const createdEnv = (await Promise.resolve(
+                this.commandManager.executeCommand(Commands.Create_Environment, {
                     showBackButton: false,
                     selectEnvironment: true,
-                })
-                .then(noop, noop);
+                }),
+            ).catch(noop)) as CreateEnvironmentResult | undefined;
+            state.path = createdEnv?.path;
         } else if (selection.label === this.noPythonInstalled.label) {
             this.commandManager.executeCommand(Commands.InstallPython).then(noop, noop);
             this.wasNoPythonInstalledItemClicked = true;
@@ -552,6 +554,7 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
                 openLabel: InterpreterQuickPickList.browsePath.openButtonLabel,
                 canSelectMany: false,
                 title: InterpreterQuickPickList.browsePath.title,
+                defaultUri: state.workspace,
             });
             if (uris && uris.length > 0) {
                 state.path = uris[0].fsPath;
@@ -563,8 +566,14 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
         return Promise.resolve();
     }
 
+    /**
+     * @returns true when an interpreter was set, undefined if the user cancelled the quickpick.
+     */
     @captureTelemetry(EventName.SELECT_INTERPRETER)
-    public async setInterpreter(): Promise<void> {
+    public async setInterpreter(options?: {
+        hideCreateVenv?: boolean;
+        showBackButton?: boolean;
+    }): Promise<SelectEnvironmentResult | undefined> {
         const targetConfig = await this.getConfigTargets();
         if (!targetConfig) {
             return;
@@ -573,11 +582,25 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
         const wkspace = targetConfig[0].folderUri;
         const interpreterState: InterpreterStateArgs = { path: undefined, workspace: wkspace };
         const multiStep = this.multiStepFactory.create<InterpreterStateArgs>();
-        await multiStep.run(
-            (input, s) => this._pickInterpreter(input, s, undefined, { showCreateEnvironment: true }),
-            interpreterState,
-        );
-
+        try {
+            await multiStep.run(
+                (input, s) =>
+                    this._pickInterpreter(input, s, undefined, {
+                        showCreateEnvironment: !options?.hideCreateVenv,
+                        showBackButton: options?.showBackButton,
+                    }),
+                interpreterState,
+            );
+        } catch (ex) {
+            if (ex === InputFlowAction.back) {
+                // User clicked back button, so we need to return this action.
+                return { action: 'Back' };
+            }
+            if (ex === InputFlowAction.cancel) {
+                // User clicked cancel button, so we need to return this action.
+                return { action: 'Cancel' };
+            }
+        }
         if (interpreterState.path !== undefined) {
             // User may choose to have an empty string stored, so variable `interpreterState.path` may be
             // an empty string, in which case we should update.
@@ -586,6 +609,7 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
             if (useEnvExtension()) {
                 await setInterpreterLegacy(interpreterState.path, wkspace);
             }
+            return { path: interpreterState.path };
         }
     }
 
@@ -686,3 +710,14 @@ function getGroup(item: IInterpreterQuickPickItem, workspacePath?: string) {
             return EnvGroups[item.interpreter.envType];
     }
 }
+
+export type SelectEnvironmentResult = {
+    /**
+     * Path to the executable python in the environment
+     */
+    readonly path?: string;
+    /*
+     * User action that resulted in exit from the create environment flow.
+     */
+    readonly action?: 'Back' | 'Cancel';
+};
diff --git a/src/client/interpreter/configuration/pythonPathUpdaterService.ts b/src/client/interpreter/configuration/pythonPathUpdaterService.ts
index 9b9cc26f845f..9814ff6ee4cb 100644
--- a/src/client/interpreter/configuration/pythonPathUpdaterService.ts
+++ b/src/client/interpreter/configuration/pythonPathUpdaterService.ts
@@ -7,7 +7,11 @@ import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { PythonInterpreterTelemetry } from '../../telemetry/types';
 import { IComponentAdapter } from '../contracts';
-import { IPythonPathUpdaterServiceFactory, IPythonPathUpdaterServiceManager } from './types';
+import {
+    IRecommendedEnvironmentService,
+    IPythonPathUpdaterServiceFactory,
+    IPythonPathUpdaterServiceManager,
+} from './types';
 
 @injectable()
 export class PythonPathUpdaterService implements IPythonPathUpdaterServiceManager {
@@ -15,6 +19,7 @@ export class PythonPathUpdaterService implements IPythonPathUpdaterServiceManage
         @inject(IPythonPathUpdaterServiceFactory)
         private readonly pythonPathSettingsUpdaterFactory: IPythonPathUpdaterServiceFactory,
         @inject(IComponentAdapter) private readonly pyenvs: IComponentAdapter,
+        @inject(IRecommendedEnvironmentService) private readonly preferredEnvService: IRecommendedEnvironmentService,
     ) {}
 
     public async updatePythonPath(
@@ -28,6 +33,9 @@ export class PythonPathUpdaterService implements IPythonPathUpdaterServiceManage
         let failed = false;
         try {
             await pythonPathUpdater.updatePythonPath(pythonPath);
+            if (trigger === 'ui') {
+                this.preferredEnvService.trackUserSelectedEnvironment(pythonPath, wkspace);
+            }
         } catch (err) {
             failed = true;
             const reason = err as Error;
diff --git a/src/client/interpreter/configuration/recommededEnvironmentService.ts b/src/client/interpreter/configuration/recommededEnvironmentService.ts
new file mode 100644
index 000000000000..39f4edfde1d6
--- /dev/null
+++ b/src/client/interpreter/configuration/recommededEnvironmentService.ts
@@ -0,0 +1,205 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { IRecommendedEnvironmentService } from './types';
+import { PythonExtension, ResolvedEnvironment } from '../../api/types';
+import { IExtensionContext, Resource } from '../../common/types';
+import { commands, Uri, workspace } from 'vscode';
+import { getWorkspaceStateValue, updateWorkspaceStateValue } from '../../common/persistentState';
+import { traceError } from '../../logging';
+import { IExtensionActivationService } from '../../activation/types';
+import { StopWatch } from '../../common/utils/stopWatch';
+import { isParentPath } from '../../common/platform/fs-paths';
+
+const MEMENTO_KEY = 'userSelectedEnvPath';
+
+@injectable()
+export class RecommendedEnvironmentService implements IRecommendedEnvironmentService, IExtensionActivationService {
+    private api?: PythonExtension['environments'];
+    private hasRegisteredCommand = false;
+    constructor(@inject(IExtensionContext) private readonly extensionContext: IExtensionContext) {}
+    supportedWorkspaceTypes: { untrustedWorkspace: boolean; virtualWorkspace: boolean } = {
+        untrustedWorkspace: true,
+        virtualWorkspace: false,
+    };
+
+    async activate(_resource: Resource, _startupStopWatch?: StopWatch): Promise<void> {
+        if (this.hasRegisteredCommand) {
+            return;
+        }
+        this.hasRegisteredCommand = true;
+        this.extensionContext.subscriptions.push(
+            commands.registerCommand('python.getRecommendedEnvironment', async (resource: Resource) => {
+                return this.getRecommededEnvironment(resource);
+            }),
+        );
+    }
+
+    registerEnvApi(api: PythonExtension['environments']) {
+        this.api = api;
+    }
+
+    trackUserSelectedEnvironment(environmentPath: string | undefined, uri: Uri | undefined) {
+        if (workspace.workspaceFolders?.length) {
+            try {
+                void updateWorkspaceStateValue(MEMENTO_KEY, getDataToStore(environmentPath, uri));
+            } catch (ex) {
+                traceError('Failed to update workspace state for preferred environment', ex);
+            }
+        } else {
+            void this.extensionContext.globalState.update(MEMENTO_KEY, environmentPath);
+        }
+    }
+
+    async getRecommededEnvironment(
+        resource: Resource,
+    ): Promise<
+        | {
+              environment: ResolvedEnvironment;
+              reason: 'globalUserSelected' | 'workspaceUserSelected' | 'defaultRecommended';
+          }
+        | undefined
+    > {
+        if (!workspace.isTrusted || !this.api) {
+            return undefined;
+        }
+        const preferred = await this.getRecommededInternal(resource);
+        if (!preferred) {
+            return undefined;
+        }
+        const activeEnv = await this.api.resolveEnvironment(this.api.getActiveEnvironmentPath(resource));
+        const recommendedEnv = await this.api.resolveEnvironment(preferred.environmentPath);
+        if (activeEnv && recommendedEnv && activeEnv.id !== recommendedEnv.id) {
+            traceError(
+                `Active environment ${activeEnv.id} is different from recommended environment ${
+                    recommendedEnv.id
+                } for resource ${resource?.toString()}`,
+            );
+            return undefined;
+        }
+        if (recommendedEnv) {
+            return { environment: recommendedEnv, reason: preferred.reason };
+        }
+        const globalEnv = await this.api.resolveEnvironment(this.api.getActiveEnvironmentPath());
+        if (activeEnv && globalEnv?.path !== activeEnv?.path) {
+            // User has definitely got a workspace specific environment selected.
+            // Given the fact that global !== workspace env, we can safely assume that
+            // at some time, the user has selected a workspace specific environment.
+            // This applies to cases where the user has selected a workspace specific environment before this version of the extension
+            // and we did not store it in the workspace state.
+            // So we can safely return the global environment as the recommended environment.
+            return { environment: activeEnv, reason: 'workspaceUserSelected' };
+        }
+        return undefined;
+    }
+    async getRecommededInternal(
+        resource: Resource,
+    ): Promise<
+        | { environmentPath: string; reason: 'globalUserSelected' | 'workspaceUserSelected' | 'defaultRecommended' }
+        | undefined
+    > {
+        let workspaceState: string | undefined = undefined;
+        try {
+            workspaceState = getWorkspaceStateValue<string>(MEMENTO_KEY);
+        } catch (ex) {
+            traceError('Failed to get workspace state for preferred environment', ex);
+        }
+
+        if (workspace.workspaceFolders?.length && workspaceState) {
+            const workspaceUri = (
+                (resource ? workspace.getWorkspaceFolder(resource)?.uri : undefined) ||
+                workspace.workspaceFolders[0].uri
+            ).toString();
+
+            try {
+                const existingJson: Record<string, string> = JSON.parse(workspaceState);
+                const selectedEnvPath = existingJson[workspaceUri];
+                if (selectedEnvPath) {
+                    return { environmentPath: selectedEnvPath, reason: 'workspaceUserSelected' };
+                }
+            } catch (ex) {
+                traceError('Failed to parse existing workspace state value for preferred environment', ex);
+            }
+        }
+
+        if (workspace.workspaceFolders?.length && this.api) {
+            // Check if we have a .venv or .conda environment in the workspace
+            // This is required for cases where user has selected a workspace specific environment
+            // but before this version of the extension, we did not store it in the workspace state.
+            const workspaceEnv = await getWorkspaceSpecificVirtualEnvironment(this.api, resource);
+            if (workspaceEnv) {
+                return { environmentPath: workspaceEnv.path, reason: 'workspaceUserSelected' };
+            }
+        }
+
+        const globalSelectedEnvPath = this.extensionContext.globalState.get<string | undefined>(MEMENTO_KEY);
+        if (globalSelectedEnvPath) {
+            return { environmentPath: globalSelectedEnvPath, reason: 'globalUserSelected' };
+        }
+        return this.api && workspace.isTrusted
+            ? {
+                  environmentPath: this.api.getActiveEnvironmentPath(resource).path,
+                  reason: 'defaultRecommended',
+              }
+            : undefined;
+    }
+}
+
+async function getWorkspaceSpecificVirtualEnvironment(api: PythonExtension['environments'], resource: Resource) {
+    const workspaceUri =
+        (resource ? workspace.getWorkspaceFolder(resource)?.uri : undefined) ||
+        (workspace.workspaceFolders?.length ? workspace.workspaceFolders[0].uri : undefined);
+    if (!workspaceUri) {
+        return undefined;
+    }
+    let workspaceEnv = api.known.find((env) => {
+        if (!env.environment?.folderUri) {
+            return false;
+        }
+        if (env.environment.type !== 'VirtualEnvironment' && env.environment.type !== 'Conda') {
+            return false;
+        }
+        return isParentPath(env.environment.folderUri.fsPath, workspaceUri.fsPath);
+    });
+    let resolvedEnv = workspaceEnv ? api.resolveEnvironment(workspaceEnv) : undefined;
+    if (resolvedEnv) {
+        return resolvedEnv;
+    }
+    workspaceEnv = api.known.find((env) => {
+        // Look for any other type of env thats inside this workspace
+        // Or look for an env thats associated with this workspace (pipenv or the like).
+        return (
+            (env.environment?.folderUri && isParentPath(env.environment.folderUri.fsPath, workspaceUri.fsPath)) ||
+            (env.environment?.workspaceFolder && env.environment.workspaceFolder.uri.fsPath === workspaceUri.fsPath)
+        );
+    });
+    return workspaceEnv ? api.resolveEnvironment(workspaceEnv) : undefined;
+}
+
+function getDataToStore(environmentPath: string | undefined, uri: Uri | undefined): string | undefined {
+    if (!workspace.workspaceFolders?.length) {
+        return environmentPath;
+    }
+    const workspaceUri = (
+        (uri ? workspace.getWorkspaceFolder(uri)?.uri : undefined) || workspace.workspaceFolders[0].uri
+    ).toString();
+    const existingData = getWorkspaceStateValue<string>(MEMENTO_KEY);
+    if (!existingData) {
+        return JSON.stringify(environmentPath ? { [workspaceUri]: environmentPath } : {});
+    }
+    try {
+        const existingJson: Record<string, string> = JSON.parse(existingData);
+        if (environmentPath) {
+            existingJson[workspaceUri] = environmentPath;
+        } else {
+            delete existingJson[workspaceUri];
+        }
+        return JSON.stringify(existingJson);
+    } catch (ex) {
+        traceError('Failed to parse existing workspace state value for preferred environment', ex);
+        return JSON.stringify({
+            [workspaceUri]: environmentPath,
+        });
+    }
+}
diff --git a/src/client/interpreter/configuration/types.ts b/src/client/interpreter/configuration/types.ts
index 08518d4d12d3..05ff8e32c18e 100644
--- a/src/client/interpreter/configuration/types.ts
+++ b/src/client/interpreter/configuration/types.ts
@@ -1,6 +1,7 @@
 import { ConfigurationTarget, Disposable, QuickPickItem, Uri } from 'vscode';
 import { Resource } from '../../common/types';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
+import { PythonExtension, ResolvedEnvironment } from '../../api/types';
 
 export interface IPythonPathUpdaterService {
     updatePythonPath(pythonPath: string | undefined): Promise<void>;
@@ -96,3 +97,18 @@ export interface IInterpreterQuickPick {
         params?: InterpreterQuickPickParams,
     ): Promise<string | undefined>;
 }
+
+export const IRecommendedEnvironmentService = Symbol('IRecommendedEnvironmentService');
+export interface IRecommendedEnvironmentService {
+    registerEnvApi(api: PythonExtension['environments']): void;
+    trackUserSelectedEnvironment(environmentPath: string | undefined, uri: Uri | undefined): void;
+    getRecommededEnvironment(
+        resource: Resource,
+    ): Promise<
+        | {
+              environment: ResolvedEnvironment;
+              reason: 'globalUserSelected' | 'workspaceUserSelected' | 'defaultRecommended';
+          }
+        | undefined
+    >;
+}
diff --git a/src/client/interpreter/display/index.ts b/src/client/interpreter/display/index.ts
index ebe7fc359cac..3a602093d4f9 100644
--- a/src/client/interpreter/display/index.ts
+++ b/src/client/interpreter/display/index.ts
@@ -24,7 +24,7 @@ import {
     IInterpreterService,
     IInterpreterStatusbarVisibilityFilter,
 } from '../contracts';
-import { useEnvExtension } from '../../envExt/api.internal';
+import { shouldEnvExtHandleActivation } from '../../envExt/api.internal';
 
 /**
  * Based on https://github.com/microsoft/vscode-python/issues/18040#issuecomment-992567670.
@@ -68,7 +68,7 @@ export class InterpreterDisplay implements IInterpreterDisplay, IExtensionSingle
     }
 
     public async activate(): Promise<void> {
-        if (useEnvExtension()) {
+        if (shouldEnvExtHandleActivation()) {
             return;
         }
         const application = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
@@ -115,7 +115,7 @@ export class InterpreterDisplay implements IInterpreterDisplay, IExtensionSingle
         }
     }
     private async updateDisplay(workspaceFolder?: Uri) {
-        if (useEnvExtension()) {
+        if (shouldEnvExtHandleActivation()) {
             this.statusBar?.hide();
             this.languageStatus?.dispose();
             this.languageStatus = undefined;
diff --git a/src/client/interpreter/helpers.ts b/src/client/interpreter/helpers.ts
index ded855cbd55b..413fa225f3ef 100644
--- a/src/client/interpreter/helpers.ts
+++ b/src/client/interpreter/helpers.ts
@@ -19,7 +19,7 @@ export function isInterpreterLocatedInWorkspace(interpreter: PythonEnvironment,
 /**
  * Build a version-sorted list from the given one, with lowest first.
  */
-function sortInterpreters(interpreters: PythonEnvironment[]): PythonEnvironment[] {
+export function sortInterpreters(interpreters: PythonEnvironment[]): PythonEnvironment[] {
     if (interpreters.length === 0) {
         return [];
     }
diff --git a/src/client/interpreter/interpreterPathCommand.ts b/src/client/interpreter/interpreterPathCommand.ts
index 0dce208c9bfc..12f6756dafeb 100644
--- a/src/client/interpreter/interpreterPathCommand.ts
+++ b/src/client/interpreter/interpreterPathCommand.ts
@@ -4,12 +4,13 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { Uri } from 'vscode';
+import { Uri, workspace } from 'vscode';
 import { IExtensionSingleActivationService } from '../activation/types';
 import { Commands } from '../common/constants';
 import { IDisposable, IDisposableRegistry } from '../common/types';
 import { registerCommand } from '../common/vscodeApis/commandApis';
 import { IInterpreterService } from './contracts';
+import { useEnvExtension } from '../envExt/api.internal';
 
 @injectable()
 export class InterpreterPathCommand implements IExtensionSingleActivationService {
@@ -26,7 +27,9 @@ export class InterpreterPathCommand implements IExtensionSingleActivationService
         );
     }
 
-    public async _getSelectedInterpreterPath(args: { workspaceFolder: string } | string[]): Promise<string> {
+    public async _getSelectedInterpreterPath(
+        args: { workspaceFolder: string; type: string } | string[],
+    ): Promise<string> {
         // If `launch.json` is launching this command, `args.workspaceFolder` carries the workspaceFolder
         // If `tasks.json` is launching this command, `args[1]` carries the workspaceFolder
         let workspaceFolder;
@@ -35,6 +38,11 @@ export class InterpreterPathCommand implements IExtensionSingleActivationService
         } else if (args[1]) {
             const [, second] = args;
             workspaceFolder = second;
+        } else if (useEnvExtension() && 'type' in args && args.type === 'debugpy') {
+            // If using the envsExt and the type is debugpy, we need to add the workspace folder to get the interpreter path.
+            if (Array.isArray(workspace.workspaceFolders) && workspace.workspaceFolders.length > 0) {
+                workspaceFolder = workspace.workspaceFolders[0].uri.fsPath;
+            }
         } else {
             workspaceFolder = undefined;
         }
diff --git a/src/client/interpreter/interpreterService.ts b/src/client/interpreter/interpreterService.ts
index 3a1aaed312ff..ad06fd7d051d 100644
--- a/src/client/interpreter/interpreterService.ts
+++ b/src/client/interpreter/interpreterService.ts
@@ -45,7 +45,7 @@ import {
 } from '../pythonEnvironments/base/locator';
 import { sleep } from '../common/utils/async';
 import { useEnvExtension } from '../envExt/api.internal';
-import { ensureEnvironmentContainsPythonLegacy, getActiveInterpreterLegacy } from '../envExt/api.legacy';
+import { getActiveInterpreterLegacy } from '../envExt/api.legacy';
 
 type StoredPythonEnvironment = PythonEnvironment & { store?: boolean };
 
@@ -290,9 +290,6 @@ export class InterpreterService implements Disposable, IInterpreterService {
     @cache(-1, true)
     private async ensureEnvironmentContainsPython(pythonPath: string, workspaceFolder: WorkspaceFolder | undefined) {
         if (useEnvExtension()) {
-            await ensureEnvironmentContainsPythonLegacy(pythonPath, workspaceFolder, () => {
-                this.didChangeInterpreterEmitter.fire(workspaceFolder?.uri);
-            });
             return;
         }
 
diff --git a/src/client/interpreter/serviceRegistry.ts b/src/client/interpreter/serviceRegistry.ts
index 688ef20cf970..f54f8e5368fe 100644
--- a/src/client/interpreter/serviceRegistry.ts
+++ b/src/client/interpreter/serviceRegistry.ts
@@ -16,12 +16,14 @@ import { InstallPythonViaTerminal } from './configuration/interpreterSelector/co
 import { ResetInterpreterCommand } from './configuration/interpreterSelector/commands/resetInterpreter';
 import { SetInterpreterCommand } from './configuration/interpreterSelector/commands/setInterpreter';
 import { InterpreterSelector } from './configuration/interpreterSelector/interpreterSelector';
+import { RecommendedEnvironmentService } from './configuration/recommededEnvironmentService';
 import { PythonPathUpdaterService } from './configuration/pythonPathUpdaterService';
 import { PythonPathUpdaterServiceFactory } from './configuration/pythonPathUpdaterServiceFactory';
 import {
     IInterpreterComparer,
     IInterpreterQuickPick,
     IInterpreterSelector,
+    IRecommendedEnvironmentService,
     IPythonPathUpdaterServiceFactory,
     IPythonPathUpdaterServiceManager,
 } from './configuration/types';
@@ -59,6 +61,11 @@ export function registerInterpreterTypes(serviceManager: IServiceManager): void
         IExtensionSingleActivationService,
         ResetInterpreterCommand,
     );
+    serviceManager.addSingleton<IRecommendedEnvironmentService>(
+        IRecommendedEnvironmentService,
+        RecommendedEnvironmentService,
+    );
+    serviceManager.addBinding(IRecommendedEnvironmentService, IExtensionActivationService);
     serviceManager.addSingleton(IInterpreterQuickPick, SetInterpreterCommand);
 
     serviceManager.addSingleton<IExtensionActivationService>(IExtensionActivationService, VirtualEnvironmentPrompt);
diff --git a/src/client/interpreter/virtualEnvs/activatedEnvLaunch.ts b/src/client/interpreter/virtualEnvs/activatedEnvLaunch.ts
index 21bcc12b0d06..6b4334e13100 100644
--- a/src/client/interpreter/virtualEnvs/activatedEnvLaunch.ts
+++ b/src/client/interpreter/virtualEnvs/activatedEnvLaunch.ts
@@ -85,12 +85,9 @@ export class ActivatedEnvironmentLaunch implements IActivatedEnvironmentLaunch {
 
     @cache(-1, true)
     private async _selectIfLaunchedViaActivatedEnv(doNotBlockOnSelection = false): Promise<string | undefined> {
-        if (this.workspaceService.workspaceFile) {
-            // Assuming multiroot workspaces cannot be directly launched via `code .` command.
-            return undefined;
-        }
         if (process.env.VSCODE_CLI !== '1') {
             // We only want to select the interpreter if VS Code was launched from the command line.
+            traceLog("Skipping ActivatedEnv Detection:  process.env.VSCODE_CLI !== '1'");
             return undefined;
         }
         traceVerbose('VS Code was not launched from the command line');
diff --git a/src/client/jupyter/jupyterIntegration.ts b/src/client/jupyter/jupyterIntegration.ts
index 1136502c1ef2..5584682f3b86 100644
--- a/src/client/jupyter/jupyterIntegration.ts
+++ b/src/client/jupyter/jupyterIntegration.ts
@@ -12,7 +12,11 @@ import { IContextKeyManager, IWorkspaceService } from '../common/application/typ
 import { JUPYTER_EXTENSION_ID, PYLANCE_EXTENSION_ID } from '../common/constants';
 import { GLOBAL_MEMENTO, IExtensions, IMemento, Resource } from '../common/types';
 import { IEnvironmentActivationService } from '../interpreter/activation/types';
-import { IInterpreterQuickPickItem, IInterpreterSelector } from '../interpreter/configuration/types';
+import {
+    IInterpreterQuickPickItem,
+    IInterpreterSelector,
+    IRecommendedEnvironmentService,
+} from '../interpreter/configuration/types';
 import {
     ICondaService,
     IInterpreterDisplay,
@@ -22,7 +26,7 @@ import {
 import { PylanceApi } from '../activation/node/pylanceApi';
 import { ExtensionContextKey } from '../common/application/contextKeys';
 import { getDebugpyPath } from '../debugger/pythonDebugger';
-import type { Environment } from '../api/types';
+import type { Environment, EnvironmentPath, PythonExtension } from '../api/types';
 import { DisposableBase } from '../common/utils/resourceLifecycle';
 
 type PythonApiForJupyterExtension = {
@@ -63,6 +67,19 @@ type PythonApiForJupyterExtension = {
      * @param func : The function that Python should call when requesting the Python path.
      */
     registerJupyterPythonPathFunction(func: (uri: Uri) => Promise<string | undefined>): void;
+
+    /**
+     * Returns the preferred environment for the given URI.
+     */
+    getRecommededEnvironment(
+        uri: Uri | undefined,
+    ): Promise<
+        | {
+              environment: EnvironmentPath;
+              reason: 'globalUserSelected' | 'workspaceUserSelected' | 'defaultRecommended';
+          }
+        | undefined
+    >;
 };
 
 type JupyterExtensionApi = {
@@ -78,6 +95,7 @@ export class JupyterExtensionIntegration {
     private jupyterExtension: Extension<JupyterExtensionApi> | undefined;
 
     private pylanceExtension: Extension<PylanceApi> | undefined;
+    private environmentApi: PythonExtension['environments'] | undefined;
 
     constructor(
         @inject(IExtensions) private readonly extensions: IExtensions,
@@ -89,7 +107,11 @@ export class JupyterExtensionIntegration {
         @inject(ICondaService) private readonly condaService: ICondaService,
         @inject(IContextKeyManager) private readonly contextManager: IContextKeyManager,
         @inject(IInterpreterService) private interpreterService: IInterpreterService,
+        @inject(IRecommendedEnvironmentService) private preferredEnvironmentService: IRecommendedEnvironmentService,
     ) {}
+    public registerEnvApi(api: PythonExtension['environments']) {
+        this.environmentApi = api;
+    }
 
     public registerApi(jupyterExtensionApi: JupyterExtensionApi): JupyterExtensionApi | undefined {
         this.contextManager.setContext(ExtensionContextKey.IsJupyterInstalled, true);
@@ -121,6 +143,12 @@ export class JupyterExtensionIntegration {
             getCondaVersion: () => this.condaService.getCondaVersion(),
             registerJupyterPythonPathFunction: (func: (uri: Uri) => Promise<string | undefined>) =>
                 this.registerJupyterPythonPathFunction(func),
+            getRecommededEnvironment: async (uri) => {
+                if (!this.environmentApi) {
+                    return undefined;
+                }
+                return this.preferredEnvironmentService.getRecommededEnvironment(uri);
+            },
         });
         return undefined;
     }
diff --git a/src/client/providers/terminalProvider.ts b/src/client/providers/terminalProvider.ts
index 407a5520b29a..f68f151110ec 100644
--- a/src/client/providers/terminalProvider.ts
+++ b/src/client/providers/terminalProvider.ts
@@ -11,7 +11,7 @@ import { swallowExceptions } from '../common/utils/decorators';
 import { IServiceContainer } from '../ioc/types';
 import { captureTelemetry, sendTelemetryEvent } from '../telemetry';
 import { EventName } from '../telemetry/constants';
-import { useEnvExtension } from '../envExt/api.internal';
+import { useEnvExtension, shouldEnvExtHandleActivation } from '../envExt/api.internal';
 
 export class TerminalProvider implements Disposable {
     private disposables: Disposable[] = [];
@@ -33,7 +33,7 @@ export class TerminalProvider implements Disposable {
             currentTerminal &&
             pythonSettings.terminal.activateEnvInCurrentTerminal &&
             !inTerminalEnvVarExperiment(experimentService) &&
-            !useEnvExtension()
+            !shouldEnvExtHandleActivation()
         ) {
             const hideFromUser =
                 'hideFromUser' in currentTerminal.creationOptions && currentTerminal.creationOptions.hideFromUser;
@@ -60,8 +60,13 @@ export class TerminalProvider implements Disposable {
 
     @captureTelemetry(EventName.TERMINAL_CREATE, { triggeredBy: 'commandpalette' })
     private async onCreateTerminal() {
-        const terminalService = this.serviceContainer.get<ITerminalServiceFactory>(ITerminalServiceFactory);
         const activeResource = this.activeResourceService.getActiveResource();
+        if (useEnvExtension()) {
+            const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
+            await commandManager.executeCommand('python-envs.createTerminal', activeResource);
+        }
+
+        const terminalService = this.serviceContainer.get<ITerminalServiceFactory>(ITerminalServiceFactory);
         await terminalService.createTerminalService(activeResource, 'Python').show(false);
     }
 }
diff --git a/src/client/pythonEnvironments/base/locators/common/nativePythonFinder.ts b/src/client/pythonEnvironments/base/locators/common/nativePythonFinder.ts
index cb5ab63077c9..ea0d63cd7552 100644
--- a/src/client/pythonEnvironments/base/locators/common/nativePythonFinder.ts
+++ b/src/client/pythonEnvironments/base/locators/common/nativePythonFinder.ts
@@ -15,18 +15,24 @@ import { noop } from '../../../../common/utils/misc';
 import { getConfiguration, getWorkspaceFolderPaths, isTrusted } from '../../../../common/vscodeApis/workspaceApis';
 import { CONDAPATH_SETTING_KEY } from '../../../common/environmentManagers/conda';
 import { VENVFOLDERS_SETTING_KEY, VENVPATH_SETTING_KEY } from '../lowLevel/customVirtualEnvLocator';
-import { createLogOutputChannel } from '../../../../common/vscodeApis/windowApis';
+import { createLogOutputChannel, showWarningMessage } from '../../../../common/vscodeApis/windowApis';
 import { sendNativeTelemetry, NativePythonTelemetry } from './nativePythonTelemetry';
 import { NativePythonEnvironmentKind } from './nativePythonUtils';
 import type { IExtensionContext } from '../../../../common/types';
 import { StopWatch } from '../../../../common/utils/stopWatch';
 import { untildify } from '../../../../common/helpers';
 import { traceError } from '../../../../logging';
+import { Common, PythonLocator } from '../../../../common/utils/localize';
+import { Commands } from '../../../../common/constants';
+import { executeCommand } from '../../../../common/vscodeApis/commandApis';
+import { getGlobalStorage, IPersistentStorage } from '../../../../common/persistentState';
 
 const PYTHON_ENV_TOOLS_PATH = isWindows()
     ? path.join(EXTENSION_ROOT_DIR, 'python-env-tools', 'bin', 'pet.exe')
     : path.join(EXTENSION_ROOT_DIR, 'python-env-tools', 'bin', 'pet');
 
+const DONT_SHOW_SPAWN_ERROR_AGAIN = 'DONT_SHOW_NATIVE_FINDER_SPAWN_ERROR_AGAIN';
+
 export interface NativeEnvInfo {
     displayName?: string;
     name?: string;
@@ -106,8 +112,13 @@ class NativePythonFinderImpl extends DisposableBase implements NativePythonFinde
         timeToRefresh: 0,
     };
 
-    constructor(private readonly cacheDirectory?: Uri) {
+    private readonly suppressErrorNotification: IPersistentStorage<boolean>;
+
+    constructor(private readonly cacheDirectory?: Uri, private readonly context?: IExtensionContext) {
         super();
+        this.suppressErrorNotification = this.context
+            ? getGlobalStorage<boolean>(this.context, DONT_SHOW_SPAWN_ERROR_AGAIN, false)
+            : ({ get: () => false, set: async () => {} } as IPersistentStorage<boolean>);
         this.connection = this.start();
         void this.configure();
         this.firstRefreshResults = this.refreshFirstTime();
@@ -212,6 +223,30 @@ class NativePythonFinderImpl extends DisposableBase implements NativePythonFinde
             proc.stderr.on('data', (data) => this.outputChannel.error(data.toString()));
             writable.pipe(proc.stdin, { end: false });
 
+            // Handle spawn errors (e.g., missing DLLs on Windows)
+            proc.on('error', (error) => {
+                this.outputChannel.error(`Python Locator process error: ${error.message}`);
+                this.outputChannel.error(`Error details: ${JSON.stringify(error)}`);
+                this.handleSpawnError(error.message);
+            });
+
+            // Handle immediate exits with error codes
+            let hasStarted = false;
+            setTimeout(() => {
+                hasStarted = true;
+            }, 1000);
+
+            proc.on('exit', (code, signal) => {
+                if (!hasStarted && code !== null && code !== 0) {
+                    const errorMessage = `Python Locator process exited immediately with code ${code}`;
+                    this.outputChannel.error(errorMessage);
+                    if (signal) {
+                        this.outputChannel.error(`Exit signal: ${signal}`);
+                    }
+                    this.handleSpawnError(errorMessage);
+                }
+            });
+
             disposables.push({
                 dispose: () => {
                     try {
@@ -397,6 +432,33 @@ class NativePythonFinderImpl extends DisposableBase implements NativePythonFinde
     async getCondaInfo(): Promise<NativeCondaInfo> {
         return this.connection.sendRequest<NativeCondaInfo>('condaInfo');
     }
+
+    private async handleSpawnError(errorMessage: string): Promise<void> {
+        // Check if user has chosen to not see this error again
+        if (this.suppressErrorNotification.get()) {
+            return;
+        }
+
+        // Check for Windows runtime DLL issues
+        if (isWindows() && errorMessage.toLowerCase().includes('vcruntime')) {
+            this.outputChannel.error(PythonLocator.windowsRuntimeMissing);
+        } else if (isWindows()) {
+            this.outputChannel.error(PythonLocator.windowsStartupFailed);
+        }
+
+        // Show notification to user
+        const selection = await showWarningMessage(
+            PythonLocator.startupFailedNotification,
+            Common.openOutputPanel,
+            Common.doNotShowAgain,
+        );
+
+        if (selection === Common.openOutputPanel) {
+            await executeCommand(Commands.ViewOutput);
+        } else if (selection === Common.doNotShowAgain) {
+            await this.suppressErrorNotification.set(true);
+        }
+    }
 }
 
 type ConfigurationOptions = {
@@ -461,7 +523,7 @@ export function getNativePythonFinder(context?: IExtensionContext): NativePython
     }
     if (!_finder) {
         const cacheDirectory = context ? getCacheDirectory(context) : undefined;
-        _finder = new NativePythonFinderImpl(cacheDirectory);
+        _finder = new NativePythonFinderImpl(cacheDirectory, context);
         if (context) {
             context.subscriptions.push(_finder);
         }
diff --git a/src/client/pythonEnvironments/base/locators/common/nativePythonUtils.ts b/src/client/pythonEnvironments/base/locators/common/nativePythonUtils.ts
index 86135924537f..716bdd444633 100644
--- a/src/client/pythonEnvironments/base/locators/common/nativePythonUtils.ts
+++ b/src/client/pythonEnvironments/base/locators/common/nativePythonUtils.ts
@@ -23,6 +23,7 @@ export enum NativePythonEnvironmentKind {
     VirtualEnvWrapper = 'VirtualEnvWrapper',
     WindowsStore = 'WindowsStore',
     WindowsRegistry = 'WindowsRegistry',
+    VenvUv = 'Uv',
 }
 
 const mapping = new Map<NativePythonEnvironmentKind, PythonEnvKind>([
@@ -36,6 +37,7 @@ const mapping = new Map<NativePythonEnvironmentKind, PythonEnvKind>([
     [NativePythonEnvironmentKind.VirtualEnv, PythonEnvKind.VirtualEnv],
     [NativePythonEnvironmentKind.VirtualEnvWrapper, PythonEnvKind.VirtualEnvWrapper],
     [NativePythonEnvironmentKind.Venv, PythonEnvKind.Venv],
+    [NativePythonEnvironmentKind.VenvUv, PythonEnvKind.Venv],
     [NativePythonEnvironmentKind.WindowsRegistry, PythonEnvKind.System],
     [NativePythonEnvironmentKind.WindowsStore, PythonEnvKind.MicrosoftStore],
     [NativePythonEnvironmentKind.Homebrew, PythonEnvKind.System],
diff --git a/src/client/pythonEnvironments/common/environmentManagers/conda.ts b/src/client/pythonEnvironments/common/environmentManagers/conda.ts
index 2fd3f3207fc5..c1bfd7d68bc2 100644
--- a/src/client/pythonEnvironments/common/environmentManagers/conda.ts
+++ b/src/client/pythonEnvironments/common/environmentManagers/conda.ts
@@ -579,6 +579,15 @@ export class Conda {
         return [...python, OUTPUT_MARKER_SCRIPT];
     }
 
+    public async getListPythonPackagesArgs(
+        env: CondaEnvInfo,
+        forShellExecution?: boolean,
+    ): Promise<string[] | undefined> {
+        const args = ['-p', env.prefix];
+
+        return [forShellExecution ? this.shellCommand : this.command, 'list', ...args];
+    }
+
     /**
      * Return the conda version. The version info is cached.
      */
diff --git a/src/client/pythonEnvironments/common/environmentManagers/condaService.ts b/src/client/pythonEnvironments/common/environmentManagers/condaService.ts
index 0739993dad37..0aa91bdbfb45 100644
--- a/src/client/pythonEnvironments/common/environmentManagers/condaService.ts
+++ b/src/client/pythonEnvironments/common/environmentManagers/condaService.ts
@@ -2,6 +2,7 @@ import { inject, injectable } from 'inversify';
 import * as path from 'path';
 import { SemVer } from 'semver';
 import { IFileSystem, IPlatformService } from '../../../common/platform/types';
+import { traceVerbose } from '../../../logging';
 import { cache } from '../../../common/utils/decorators';
 import { ICondaService } from '../../../interpreter/contracts';
 import { traceDecoratorVerbose } from '../../../logging';
@@ -23,12 +24,15 @@ export class CondaService implements ICondaService {
         interpreterPath?: string,
         envName?: string,
     ): Promise<{ path: string | undefined; type: 'local' | 'global' } | undefined> {
+        traceVerbose(`Getting activation script for interpreter ${interpreterPath}, env ${envName}`);
         const condaPath = await this.getCondaFileFromInterpreter(interpreterPath, envName);
+        traceVerbose(`Found conda path: ${condaPath}`);
 
         const activatePath = (condaPath
             ? path.join(path.dirname(condaPath), 'activate')
             : 'activate'
         ).fileToCommandArgumentForPythonExt(); // maybe global activate?
+        traceVerbose(`Using activate path: ${activatePath}`);
 
         // try to find the activate script in the global conda root prefix.
         if (this.platform.isLinux || this.platform.isMac) {
@@ -41,6 +45,7 @@ export class CondaService implements ICondaService {
                     .fileToCommandArgumentForPythonExt();
 
                 if (activatePath === globalActivatePath || !(await this.fileSystem.fileExists(activatePath))) {
+                    traceVerbose(`Using global activate path: ${globalActivatePath}`);
                     return {
                         path: globalActivatePath,
                         type: 'global',
diff --git a/src/client/pythonEnvironments/creation/createEnvApi.ts b/src/client/pythonEnvironments/creation/createEnvApi.ts
index ab0f0db317c3..899f57728804 100644
--- a/src/client/pythonEnvironments/creation/createEnvApi.ts
+++ b/src/client/pythonEnvironments/creation/createEnvApi.ts
@@ -3,12 +3,12 @@
 
 import { ConfigurationTarget, Disposable, QuickInputButtons } from 'vscode';
 import { Commands } from '../../common/constants';
-import { IDisposableRegistry, IInterpreterPathService, IPathUtils } from '../../common/types';
+import { IDisposableRegistry, IPathUtils } from '../../common/types';
 import { executeCommand, registerCommand } from '../../common/vscodeApis/commandApis';
-import { IInterpreterQuickPick } from '../../interpreter/configuration/types';
+import { IInterpreterQuickPick, IPythonPathUpdaterServiceManager } from '../../interpreter/configuration/types';
 import { getCreationEvents, handleCreateEnvironmentCommand } from './createEnvironment';
 import { condaCreationProvider } from './provider/condaCreationProvider';
-import { VenvCreationProvider } from './provider/venvCreationProvider';
+import { VenvCreationProvider, VenvCreationProviderId } from './provider/venvCreationProvider';
 import { showInformationMessage } from '../../common/vscodeApis/windowApis';
 import { CreateEnv } from '../../common/utils/localize';
 import {
@@ -61,7 +61,7 @@ export const { onCreateEnvironmentStarted, onCreateEnvironmentExited, isCreating
 export function registerCreateEnvironmentFeatures(
     disposables: IDisposableRegistry,
     interpreterQuickPick: IInterpreterQuickPick,
-    interpreterPathService: IInterpreterPathService,
+    pythonPathUpdater: IPythonPathUpdaterServiceManager,
     pathUtils: IPathUtils,
 ): void {
     disposables.push(
@@ -72,8 +72,28 @@ export function registerCreateEnvironmentFeatures(
             ): Promise<CreateEnvironmentResult | undefined> => {
                 if (useEnvExtension()) {
                     try {
-                        const result = await executeCommand<PythonEnvironment | undefined>('python-envs.createAny');
+                        sendTelemetryEvent(EventName.ENVIRONMENT_CREATING, undefined, {
+                            environmentType: undefined,
+                            pythonVersion: undefined,
+                        });
+                        const result = await executeCommand<PythonEnvironment | undefined>(
+                            'python-envs.createAny',
+                            options,
+                        );
                         if (result) {
+                            const managerId = result.envId.managerId;
+                            if (managerId === 'ms-python.python:venv') {
+                                sendTelemetryEvent(EventName.ENVIRONMENT_CREATED, undefined, {
+                                    environmentType: 'venv',
+                                    reason: 'created',
+                                });
+                            }
+                            if (managerId === 'ms-python.python:conda') {
+                                sendTelemetryEvent(EventName.ENVIRONMENT_CREATED, undefined, {
+                                    environmentType: 'conda',
+                                    reason: 'created',
+                                });
+                            }
                             return { path: result.environmentPath.path };
                         }
                     } catch (err) {
@@ -100,10 +120,11 @@ export function registerCreateEnvironmentFeatures(
         registerCreateEnvironmentProvider(condaCreationProvider()),
         onCreateEnvironmentExited(async (e: EnvironmentDidCreateEvent) => {
             if (e.path && e.options?.selectEnvironment) {
-                await interpreterPathService.update(
-                    e.workspaceFolder?.uri,
-                    ConfigurationTarget.WorkspaceFolder,
+                await pythonPathUpdater.updatePythonPath(
                     e.path,
+                    ConfigurationTarget.WorkspaceFolder,
+                    'ui',
+                    e.workspaceFolder?.uri,
                 );
                 showInformationMessage(`${CreateEnv.informEnvCreation} ${pathUtils.getDisplayName(e.path)}`);
             }
@@ -129,3 +150,11 @@ export function buildEnvironmentCreationApi(): ProposedCreateEnvironmentAPI {
             registerCreateEnvironmentProvider(provider),
     };
 }
+
+export async function createVirtualEnvironment(options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal) {
+    const provider = _createEnvironmentProviders.getAll().find((p) => p.id === VenvCreationProviderId);
+    if (!provider) {
+        return;
+    }
+    return handleCreateEnvironmentCommand([provider], { ...options, providerId: provider.id });
+}
diff --git a/src/client/pythonEnvironments/creation/provider/condaCreationProvider.ts b/src/client/pythonEnvironments/creation/provider/condaCreationProvider.ts
index d923179fac73..a7e4e9a21cd1 100644
--- a/src/client/pythonEnvironments/creation/provider/condaCreationProvider.ts
+++ b/src/client/pythonEnvironments/creation/provider/condaCreationProvider.ts
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { CancellationToken, ProgressLocation, WorkspaceFolder } from 'vscode';
+import { CancellationToken, CancellationTokenSource, ProgressLocation, WorkspaceFolder } from 'vscode';
 import * as path from 'path';
 import { Commands, PVSC_EXTENSION_ID } from '../../../common/constants';
 import { traceError, traceInfo, traceLog } from '../../../logging';
@@ -35,6 +35,8 @@ import {
     CreateEnvironmentResult,
     CreateEnvironmentProvider,
 } from '../proposed.createEnvApis';
+import { shouldDisplayEnvCreationProgress } from './hideEnvCreation';
+import { noop } from '../../../common/utils/misc';
 
 function generateCommandArgs(version?: string, options?: CreateEnvironmentOptions): string[] {
     let addGitIgnore = true;
@@ -261,6 +263,50 @@ async function createEnvironment(options?: CreateEnvironmentOptions): Promise<Cr
         }
     }
 
+    const createEnvInternal = async (progress: CreateEnvironmentProgress, token: CancellationToken) => {
+        progress.report({
+            message: CreateEnv.statusStarting,
+        });
+
+        let envPath: string | undefined;
+        try {
+            sendTelemetryEvent(EventName.ENVIRONMENT_CREATING, undefined, {
+                environmentType: 'conda',
+                pythonVersion: version,
+            });
+            if (workspace) {
+                envPath = await createCondaEnv(
+                    workspace,
+                    getExecutableCommand(conda),
+                    generateCommandArgs(version, options),
+                    progress,
+                    token,
+                );
+
+                if (envPath) {
+                    return { path: envPath, workspaceFolder: workspace };
+                }
+
+                throw new Error('Failed to create conda environment. See Output > Python for more info.');
+            } else {
+                throw new Error('A workspace is needed to create conda environment');
+            }
+        } catch (ex) {
+            traceError(ex);
+            showErrorMessageWithLogs(CreateEnv.Conda.errorCreatingEnvironment);
+            return { error: ex as Error };
+        }
+    };
+
+    if (!shouldDisplayEnvCreationProgress()) {
+        const token = new CancellationTokenSource();
+        try {
+            return await createEnvInternal({ report: noop }, token.token);
+        } finally {
+            token.dispose();
+        }
+    }
+
     return withProgress(
         {
             location: ProgressLocation.Notification,
@@ -270,40 +316,7 @@ async function createEnvironment(options?: CreateEnvironmentOptions): Promise<Cr
         async (
             progress: CreateEnvironmentProgress,
             token: CancellationToken,
-        ): Promise<CreateEnvironmentResult | undefined> => {
-            progress.report({
-                message: CreateEnv.statusStarting,
-            });
-
-            let envPath: string | undefined;
-            try {
-                sendTelemetryEvent(EventName.ENVIRONMENT_CREATING, undefined, {
-                    environmentType: 'conda',
-                    pythonVersion: version,
-                });
-                if (workspace) {
-                    envPath = await createCondaEnv(
-                        workspace,
-                        getExecutableCommand(conda),
-                        generateCommandArgs(version, options),
-                        progress,
-                        token,
-                    );
-
-                    if (envPath) {
-                        return { path: envPath, workspaceFolder: workspace };
-                    }
-
-                    throw new Error('Failed to create conda environment. See Output > Python for more info.');
-                } else {
-                    throw new Error('A workspace is needed to create conda environment');
-                }
-            } catch (ex) {
-                traceError(ex);
-                showErrorMessageWithLogs(CreateEnv.Conda.errorCreatingEnvironment);
-                return { error: ex as Error };
-            }
-        },
+        ): Promise<CreateEnvironmentResult | undefined> => createEnvInternal(progress, token),
     );
 }
 
diff --git a/src/client/pythonEnvironments/creation/provider/hideEnvCreation.ts b/src/client/pythonEnvironments/creation/provider/hideEnvCreation.ts
new file mode 100644
index 000000000000..5c29a8d7128d
--- /dev/null
+++ b/src/client/pythonEnvironments/creation/provider/hideEnvCreation.ts
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Disposable } from 'vscode';
+
+const envCreationTracker: Disposable[] = [];
+
+export function hideEnvCreation(): Disposable {
+    const disposable = new Disposable(() => {
+        const index = envCreationTracker.indexOf(disposable);
+        if (index > -1) {
+            envCreationTracker.splice(index, 1);
+        }
+    });
+    envCreationTracker.push(disposable);
+    return disposable;
+}
+
+export function shouldDisplayEnvCreationProgress(): boolean {
+    return envCreationTracker.length === 0;
+}
diff --git a/src/client/pythonEnvironments/creation/provider/venvCreationProvider.ts b/src/client/pythonEnvironments/creation/provider/venvCreationProvider.ts
index 6b6ce182e887..c5c82b85357f 100644
--- a/src/client/pythonEnvironments/creation/provider/venvCreationProvider.ts
+++ b/src/client/pythonEnvironments/creation/provider/venvCreationProvider.ts
@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import * as os from 'os';
-import { CancellationToken, ProgressLocation, WorkspaceFolder } from 'vscode';
+import { CancellationToken, CancellationTokenSource, ProgressLocation, WorkspaceFolder } from 'vscode';
 import { Commands, PVSC_EXTENSION_ID } from '../../../common/constants';
 import { createVenvScript } from '../../../common/process/internal/scripts';
 import { execObservable } from '../../../common/process/rawProcessApis';
@@ -31,6 +31,8 @@ import {
     CreateEnvironmentOptions,
     CreateEnvironmentResult,
 } from '../proposed.createEnvApis';
+import { shouldDisplayEnvCreationProgress } from './hideEnvCreation';
+import { noop } from '../../../common/utils/misc';
 
 interface IVenvCommandArgs {
     argv: string[];
@@ -149,21 +151,26 @@ async function createVenv(
     return deferred.promise;
 }
 
+export const VenvCreationProviderId = `${PVSC_EXTENSION_ID}:venv`;
 export class VenvCreationProvider implements CreateEnvironmentProvider {
     constructor(private readonly interpreterQuickPick: IInterpreterQuickPick) {}
 
     public async createEnvironment(
         options?: CreateEnvironmentOptions & CreateEnvironmentOptionsInternal,
     ): Promise<CreateEnvironmentResult | undefined> {
-        let workspace: WorkspaceFolder | undefined;
+        let workspace = options?.workspaceFolder;
+        const bypassQuickPicks = options?.workspaceFolder && options.interpreter && options.providerId ? true : false;
         const workspaceStep = new MultiStepNode(
             undefined,
             async (context?: MultiStepAction) => {
                 try {
-                    workspace = (await pickWorkspaceFolder(
-                        { preSelectedWorkspace: options?.workspaceFolder },
-                        context,
-                    )) as WorkspaceFolder | undefined;
+                    workspace =
+                        workspace && bypassQuickPicks
+                            ? workspace
+                            : ((await pickWorkspaceFolder(
+                                  { preSelectedWorkspace: options?.workspaceFolder },
+                                  context,
+                              )) as WorkspaceFolder | undefined);
                 } catch (ex) {
                     if (ex === MultiStepAction.Back || ex === MultiStepAction.Cancel) {
                         return ex;
@@ -182,6 +189,9 @@ export class VenvCreationProvider implements CreateEnvironmentProvider {
         );
 
         let existingVenvAction: ExistingVenvAction | undefined;
+        if (bypassQuickPicks) {
+            existingVenvAction = ExistingVenvAction.Create;
+        }
         const existingEnvStep = new MultiStepNode(
             workspaceStep,
             async (context?: MultiStepAction) => {
@@ -204,7 +214,7 @@ export class VenvCreationProvider implements CreateEnvironmentProvider {
         );
         workspaceStep.next = existingEnvStep;
 
-        let interpreter: string | undefined;
+        let interpreter = options?.interpreter;
         const interpreterStep = new MultiStepNode(
             existingEnvStep,
             async (context?: MultiStepAction) => {
@@ -214,22 +224,25 @@ export class VenvCreationProvider implements CreateEnvironmentProvider {
                         existingVenvAction === ExistingVenvAction.Create
                     ) {
                         try {
-                            interpreter = await this.interpreterQuickPick.getInterpreterViaQuickPick(
-                                workspace.uri,
-                                (i: PythonEnvironment) =>
-                                    [
-                                        EnvironmentType.System,
-                                        EnvironmentType.MicrosoftStore,
-                                        EnvironmentType.Global,
-                                        EnvironmentType.Pyenv,
-                                    ].includes(i.envType) && i.type === undefined, // only global intepreters
-                                {
-                                    skipRecommended: true,
-                                    showBackButton: true,
-                                    placeholder: CreateEnv.Venv.selectPythonPlaceHolder,
-                                    title: null,
-                                },
-                            );
+                            interpreter =
+                                interpreter && bypassQuickPicks
+                                    ? interpreter
+                                    : await this.interpreterQuickPick.getInterpreterViaQuickPick(
+                                          workspace.uri,
+                                          (i: PythonEnvironment) =>
+                                              [
+                                                  EnvironmentType.System,
+                                                  EnvironmentType.MicrosoftStore,
+                                                  EnvironmentType.Global,
+                                                  EnvironmentType.Pyenv,
+                                              ].includes(i.envType) && i.type === undefined, // only global intepreters
+                                          {
+                                              skipRecommended: true,
+                                              showBackButton: true,
+                                              placeholder: CreateEnv.Venv.selectPythonPlaceHolder,
+                                              title: null,
+                                          },
+                                      );
                         } catch (ex) {
                             if (ex === InputFlowAction.back) {
                                 return MultiStepAction.Back;
@@ -322,6 +335,36 @@ export class VenvCreationProvider implements CreateEnvironmentProvider {
         }
 
         const args = generateCommandArgs(installInfo, addGitIgnore);
+        const createEnvInternal = async (progress: CreateEnvironmentProgress, token: CancellationToken) => {
+            progress.report({
+                message: CreateEnv.statusStarting,
+            });
+
+            let envPath: string | undefined;
+            try {
+                if (interpreter && workspace) {
+                    envPath = await createVenv(workspace, interpreter, args, progress, token);
+                    if (envPath) {
+                        return { path: envPath, workspaceFolder: workspace };
+                    }
+                    throw new Error('Failed to create virtual environment. See Output > Python for more info.');
+                }
+                throw new Error('Failed to create virtual environment. Either interpreter or workspace is undefined.');
+            } catch (ex) {
+                traceError(ex);
+                showErrorMessageWithLogs(CreateEnv.Venv.errorCreatingEnvironment);
+                return { error: ex as Error };
+            }
+        };
+
+        if (!shouldDisplayEnvCreationProgress()) {
+            const token = new CancellationTokenSource();
+            try {
+                return await createEnvInternal({ report: noop }, token.token);
+            } finally {
+                token.dispose();
+            }
+        }
 
         return withProgress(
             {
@@ -332,29 +375,7 @@ export class VenvCreationProvider implements CreateEnvironmentProvider {
             async (
                 progress: CreateEnvironmentProgress,
                 token: CancellationToken,
-            ): Promise<CreateEnvironmentResult | undefined> => {
-                progress.report({
-                    message: CreateEnv.statusStarting,
-                });
-
-                let envPath: string | undefined;
-                try {
-                    if (interpreter && workspace) {
-                        envPath = await createVenv(workspace, interpreter, args, progress, token);
-                        if (envPath) {
-                            return { path: envPath, workspaceFolder: workspace };
-                        }
-                        throw new Error('Failed to create virtual environment. See Output > Python for more info.');
-                    }
-                    throw new Error(
-                        'Failed to create virtual environment. Either interpreter or workspace is undefined.',
-                    );
-                } catch (ex) {
-                    traceError(ex);
-                    showErrorMessageWithLogs(CreateEnv.Venv.errorCreatingEnvironment);
-                    return { error: ex as Error };
-                }
-            },
+            ): Promise<CreateEnvironmentResult | undefined> => createEnvInternal(progress, token),
         );
     }
 
@@ -362,7 +383,7 @@ export class VenvCreationProvider implements CreateEnvironmentProvider {
 
     description: string = CreateEnv.Venv.providerDescription;
 
-    id = `${PVSC_EXTENSION_ID}:venv`;
+    id = VenvCreationProviderId;
 
     tools = ['Venv'];
 }
diff --git a/src/client/pythonEnvironments/creation/registrations.ts b/src/client/pythonEnvironments/creation/registrations.ts
index 8611520fc0f2..25141cbec5ac 100644
--- a/src/client/pythonEnvironments/creation/registrations.ts
+++ b/src/client/pythonEnvironments/creation/registrations.ts
@@ -1,8 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { IDisposableRegistry, IInterpreterPathService, IPathUtils } from '../../common/types';
-import { IInterpreterQuickPick } from '../../interpreter/configuration/types';
+import { IDisposableRegistry, IPathUtils } from '../../common/types';
+import { IInterpreterQuickPick, IPythonPathUpdaterServiceManager } from '../../interpreter/configuration/types';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { registerCreateEnvironmentFeatures } from './createEnvApi';
 import { registerCreateEnvironmentButtonFeatures } from './createEnvButtonContext';
@@ -13,11 +13,11 @@ import { registerPyProjectTomlFeatures } from './pyProjectTomlContext';
 export function registerAllCreateEnvironmentFeatures(
     disposables: IDisposableRegistry,
     interpreterQuickPick: IInterpreterQuickPick,
-    interpreterPathService: IInterpreterPathService,
+    pythonPathUpdater: IPythonPathUpdaterServiceManager,
     interpreterService: IInterpreterService,
     pathUtils: IPathUtils,
 ): void {
-    registerCreateEnvironmentFeatures(disposables, interpreterQuickPick, interpreterPathService, pathUtils);
+    registerCreateEnvironmentFeatures(disposables, interpreterQuickPick, pythonPathUpdater, pathUtils);
     registerCreateEnvironmentButtonFeatures(disposables);
     registerPyProjectTomlFeatures(disposables);
     registerInstalledPackagesDiagnosticsProvider(disposables, interpreterService);
diff --git a/src/client/pythonEnvironments/creation/types.ts b/src/client/pythonEnvironments/creation/types.ts
index e317bfa6cd11..0e400c2d90f3 100644
--- a/src/client/pythonEnvironments/creation/types.ts
+++ b/src/client/pythonEnvironments/creation/types.ts
@@ -5,7 +5,12 @@ import { Progress, WorkspaceFolder } from 'vscode';
 
 export interface CreateEnvironmentProgress extends Progress<{ message?: string; increment?: number }> {}
 
+/**
+ * The interpreter path to use for the environment creation. If not provided, will prompt the user to select one.
+ * If the value of `interpreter` & `workspaceFolder` & `providerId` are provided we will not prompt the user to select a provider, nor folder, nor an interpreter.
+ */
 export interface CreateEnvironmentOptionsInternal {
     workspaceFolder?: WorkspaceFolder;
     providerId?: string;
+    interpreter?: string;
 }
diff --git a/src/client/pythonEnvironments/info/pythonVersion.ts b/src/client/pythonEnvironments/info/pythonVersion.ts
index 92260dbb2d3f..d61fcf14db4d 100644
--- a/src/client/pythonEnvironments/info/pythonVersion.ts
+++ b/src/client/pythonEnvironments/info/pythonVersion.ts
@@ -25,3 +25,11 @@ export type PythonVersion = {
     build: string[];
     prerelease: string[];
 };
+
+export function isStableVersion(version: PythonVersion): boolean {
+    // A stable version is one that has no prerelease tags.
+    return (
+        version.prerelease.length === 0 &&
+        (version.build.length === 0 || (version.build.length === 1 && version.build[0] === 'final'))
+    );
+}
diff --git a/src/client/pythonEnvironments/legacyIOC.ts b/src/client/pythonEnvironments/legacyIOC.ts
index 9d161f8b1b9f..49df2ee03f21 100644
--- a/src/client/pythonEnvironments/legacyIOC.ts
+++ b/src/client/pythonEnvironments/legacyIOC.ts
@@ -26,7 +26,7 @@ import { asyncFilter } from '../common/utils/arrayUtils';
 import { CondaEnvironmentInfo, isCondaEnvironment } from './common/environmentManagers/conda';
 import { isMicrosoftStoreEnvironment } from './common/environmentManagers/microsoftStoreEnv';
 import { CondaService } from './common/environmentManagers/condaService';
-import { traceVerbose } from '../logging';
+import { traceError, traceVerbose } from '../logging';
 
 const convertedKinds = new Map(
     Object.entries({
@@ -46,6 +46,10 @@ const convertedKinds = new Map(
     }),
 );
 
+export function convertEnvInfoToPythonEnvironment(info: PythonEnvInfo): PythonEnvironment {
+    return convertEnvInfo(info);
+}
+
 function convertEnvInfo(info: PythonEnvInfo): PythonEnvironment {
     const { name, location, executable, arch, kind, version, distro, id } = info;
     const { filename, sysPrefix } = executable;
@@ -159,11 +163,16 @@ class ComponentAdapter implements IComponentAdapter {
 
     // We use the same getInterpreters() here as for IInterpreterLocatorService.
     public async getInterpreterDetails(pythonPath: string): Promise<PythonEnvironment | undefined> {
-        const env = await this.api.resolveEnv(pythonPath);
-        if (!env) {
+        try {
+            const env = await this.api.resolveEnv(pythonPath);
+            if (!env) {
+                return undefined;
+            }
+            return convertEnvInfo(env);
+        } catch (ex) {
+            traceError(`Failed to resolve interpreter: ${pythonPath}`, ex);
             return undefined;
         }
-        return convertEnvInfo(env);
     }
 
     // Implements ICondaService
diff --git a/src/client/pythonEnvironments/nativeAPI.ts b/src/client/pythonEnvironments/nativeAPI.ts
index a4a706fcb42b..62695c8dd543 100644
--- a/src/client/pythonEnvironments/nativeAPI.ts
+++ b/src/client/pythonEnvironments/nativeAPI.ts
@@ -112,14 +112,14 @@ function getDisplayName(version: PythonVersion, kind: PythonEnvKind, arch: Archi
     const kindStr = kindToShortString(kind);
     if (arch === Architecture.x86) {
         if (kindStr) {
-            return name ? `Python ${versionStr} 32-bit ('${name}')` : `Python ${versionStr} 32-bit (${kindStr})`;
+            return name ? `Python ${versionStr} 32-bit (${name})` : `Python ${versionStr} 32-bit (${kindStr})`;
         }
-        return name ? `Python ${versionStr} 32-bit ('${name}')` : `Python ${versionStr} 32-bit`;
+        return name ? `Python ${versionStr} 32-bit (${name})` : `Python ${versionStr} 32-bit`;
     }
     if (kindStr) {
-        return name ? `Python ${versionStr} ('${name}')` : `Python ${versionStr} (${kindStr})`;
+        return name ? `Python ${versionStr} (${name})` : `Python ${versionStr} (${kindStr})`;
     }
-    return name ? `Python ${versionStr} ('${name}')` : `Python ${versionStr}`;
+    return name ? `Python ${versionStr} (${name})` : `Python ${versionStr}`;
 }
 
 function validEnv(nativeEnv: NativeEnvInfo): boolean {
@@ -476,14 +476,18 @@ class NativePythonEnvironments implements IDiscoveryAPI, Disposable {
         if (envPath === undefined) {
             return undefined;
         }
-        const native = await this.finder.resolve(envPath);
-        if (native) {
-            if (native.kind === NativePythonEnvironmentKind.Conda && this._condaEnvDirs.length === 0) {
-                this._condaEnvDirs = (await getCondaEnvDirs()) ?? [];
+        try {
+            const native = await this.finder.resolve(envPath);
+            if (native) {
+                if (native.kind === NativePythonEnvironmentKind.Conda && this._condaEnvDirs.length === 0) {
+                    this._condaEnvDirs = (await getCondaEnvDirs()) ?? [];
+                }
+                return this.addEnv(native);
             }
-            return this.addEnv(native);
+            return undefined;
+        } catch {
+            return undefined;
         }
-        return undefined;
     }
 
     private initializeWatcher(): void {
diff --git a/src/client/repl/nativeRepl.ts b/src/client/repl/nativeRepl.ts
index 6edd3cbd70a7..3f8a085da467 100644
--- a/src/client/repl/nativeRepl.ts
+++ b/src/client/repl/nativeRepl.ts
@@ -1,19 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
 // Native Repl class that holds instance of pythonServer and replController
 
-import {
-    NotebookController,
-    NotebookControllerAffinity,
-    NotebookDocument,
-    QuickPickItem,
-    TextEditor,
-    Uri,
-    workspace,
-    WorkspaceFolder,
-} from 'vscode';
+import { NotebookController, NotebookDocument, QuickPickItem, TextEditor, Uri, WorkspaceFolder } from 'vscode';
+import * as path from 'path';
 import { Disposable } from 'vscode-jsonrpc';
 import { PVSC_EXTENSION_ID } from '../common/constants';
-import { showQuickPick } from '../common/vscodeApis/windowApis';
-import { getWorkspaceFolders } from '../common/vscodeApis/workspaceApis';
+import { showNotebookDocument, showQuickPick } from '../common/vscodeApis/windowApis';
+import { getWorkspaceFolders, onDidCloseNotebookDocument } from '../common/vscodeApis/workspaceApis';
 import { PythonEnvironment } from '../pythonEnvironments/info';
 import { createPythonServer, PythonServer } from './pythonServer';
 import { executeNotebookCell, openInteractiveREPL, selectNotebookKernel } from './replCommandHandler';
@@ -24,6 +19,8 @@ import { VariablesProvider } from './variables/variablesProvider';
 import { VariableRequester } from './variables/variableRequester';
 import { getTabNameForUri } from './replUtils';
 import { getWorkspaceStateValue, updateWorkspaceStateValue } from '../common/persistentState';
+import { onDidChangeEnvironmentEnvExt, useEnvExtension } from '../envExt/api.internal';
+import { getActiveInterpreterLegacy } from '../envExt/api.legacy';
 
 export const NATIVE_REPL_URI_MEMENTO = 'nativeReplUri';
 let nativeRepl: NativeRepl | undefined;
@@ -43,6 +40,10 @@ export class NativeRepl implements Disposable {
 
     public newReplSession: boolean | undefined = true;
 
+    private envChangeListenerRegistered = false;
+
+    private pendingInterpreterChange?: { resource?: Uri };
+
     // TODO: In the future, could also have attribute of URI for file specific REPL.
     private constructor() {
         this.watchNotebookClosed();
@@ -54,7 +55,9 @@ export class NativeRepl implements Disposable {
         nativeRepl.interpreter = interpreter;
         await nativeRepl.setReplDirectory();
         nativeRepl.pythonServer = createPythonServer([interpreter.path as string], nativeRepl.cwd);
+        nativeRepl.disposables.push(nativeRepl.pythonServer);
         nativeRepl.setReplController();
+        nativeRepl.registerInterpreterChangeHandler();
 
         return nativeRepl;
     }
@@ -69,11 +72,18 @@ export class NativeRepl implements Disposable {
      */
     private watchNotebookClosed(): void {
         this.disposables.push(
-            workspace.onDidCloseNotebookDocument(async (nb) => {
+            onDidCloseNotebookDocument(async (nb) => {
                 if (this.notebookDocument && nb.uri.toString() === this.notebookDocument.uri.toString()) {
                     this.notebookDocument = undefined;
                     this.newReplSession = true;
                     await updateWorkspaceStateValue<string | undefined>(NATIVE_REPL_URI_MEMENTO, undefined);
+                    this.pythonServer.dispose();
+                    this.pythonServer = createPythonServer([this.interpreter.path as string], this.cwd);
+                    this.disposables.push(this.pythonServer);
+                    if (this.replController) {
+                        this.replController.dispose();
+                    }
+                    nativeRepl = undefined;
                 }
             }),
         );
@@ -115,8 +125,8 @@ export class NativeRepl implements Disposable {
     /**
      * Function that check if NotebookController for REPL exists, and returns it in Singleton manner.
      */
-    public setReplController(): NotebookController {
-        if (!this.replController) {
+    public setReplController(force: boolean = false): NotebookController {
+        if (!this.replController || force) {
             this.replController = createReplController(this.interpreter!.path, this.disposables, this.cwd);
             this.replController.variableProvider = new VariablesProvider(
                 new VariableRequester(this.pythonServer),
@@ -127,6 +137,64 @@ export class NativeRepl implements Disposable {
         return this.replController;
     }
 
+    private registerInterpreterChangeHandler(): void {
+        if (!useEnvExtension() || this.envChangeListenerRegistered) {
+            return;
+        }
+        this.envChangeListenerRegistered = true;
+        this.disposables.push(
+            onDidChangeEnvironmentEnvExt((event) => {
+                this.updateInterpreterForChange(event.uri).catch(() => undefined);
+            }),
+        );
+        this.disposables.push(
+            this.pythonServer.onCodeExecuted(() => {
+                if (this.pendingInterpreterChange) {
+                    const { resource } = this.pendingInterpreterChange;
+                    this.pendingInterpreterChange = undefined;
+                    this.updateInterpreterForChange(resource).catch(() => undefined);
+                }
+            }),
+        );
+    }
+
+    private async updateInterpreterForChange(resource?: Uri): Promise<void> {
+        if (this.pythonServer?.isExecuting) {
+            this.pendingInterpreterChange = { resource };
+            return;
+        }
+        if (!this.shouldApplyInterpreterChange(resource)) {
+            return;
+        }
+        const scope = resource ?? (this.cwd ? Uri.file(this.cwd) : undefined);
+        const interpreter = await getActiveInterpreterLegacy(scope);
+        if (!interpreter || interpreter.path === this.interpreter?.path) {
+            return;
+        }
+
+        this.interpreter = interpreter;
+        this.pythonServer.dispose();
+        this.pythonServer = createPythonServer([interpreter.path as string], this.cwd);
+        this.disposables.push(this.pythonServer);
+        if (this.replController) {
+            this.replController.dispose();
+        }
+        this.setReplController(true);
+
+        if (this.notebookDocument) {
+            const notebookEditor = await showNotebookDocument(this.notebookDocument, { preserveFocus: true });
+            await selectNotebookKernel(notebookEditor, this.replController.id, PVSC_EXTENSION_ID);
+        }
+    }
+
+    private shouldApplyInterpreterChange(resource?: Uri): boolean {
+        if (!resource || !this.cwd) {
+            return true;
+        }
+        const relative = path.relative(this.cwd, resource.fsPath);
+        return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+    }
+
     /**
      * Function that checks if native REPL's text input box contains complete code.
      * @returns Promise<boolean> - True if complete/Valid code is present, False otherwise.
@@ -163,24 +231,19 @@ export class NativeRepl implements Disposable {
             }
         }
 
-        const notebookEditor = await openInteractiveREPL(
-            this.replController,
-            this.notebookDocument ?? wsMementoUri,
-            preserveFocus,
-        );
-        if (notebookEditor) {
-            this.notebookDocument = notebookEditor.notebook;
+        const result = await openInteractiveREPL(this.notebookDocument ?? wsMementoUri, preserveFocus);
+        if (result) {
+            this.notebookDocument = result.notebookEditor.notebook;
             await updateWorkspaceStateValue<string | undefined>(
                 NATIVE_REPL_URI_MEMENTO,
                 this.notebookDocument.uri.toString(),
             );
 
-            if (this.notebookDocument) {
-                this.replController.updateNotebookAffinity(this.notebookDocument, NotebookControllerAffinity.Default);
-                await selectNotebookKernel(notebookEditor, this.replController.id, PVSC_EXTENSION_ID);
-                if (code) {
-                    await executeNotebookCell(notebookEditor, code);
-                }
+            if (result.documentCreated) {
+                await selectNotebookKernel(result.notebookEditor, this.replController.id, PVSC_EXTENSION_ID);
+            }
+            if (code) {
+                await executeNotebookCell(result.notebookEditor, code);
             }
         }
     }
diff --git a/src/client/repl/pythonServer.ts b/src/client/repl/pythonServer.ts
index 570433714f98..c4b1722b5079 100644
--- a/src/client/repl/pythonServer.ts
+++ b/src/client/repl/pythonServer.ts
@@ -16,6 +16,8 @@ export interface ExecutionResult {
 
 export interface PythonServer extends Disposable {
     onCodeExecuted: Event<void>;
+    readonly isExecuting: boolean;
+    readonly isDisposed: boolean;
     execute(code: string): Promise<ExecutionResult | undefined>;
     executeSilently(code: string): Promise<ExecutionResult | undefined>;
     interrupt(): void;
@@ -30,6 +32,18 @@ class PythonServerImpl implements PythonServer, Disposable {
 
     onCodeExecuted = this._onCodeExecuted.event;
 
+    private inFlightRequests = 0;
+
+    private disposed = false;
+
+    public get isExecuting(): boolean {
+        return this.inFlightRequests > 0;
+    }
+
+    public get isDisposed(): boolean {
+        return this.disposed;
+    }
+
     constructor(private connection: rpc.MessageConnection, private pythonServer: ch.ChildProcess) {
         this.initialize();
         this.input();
@@ -41,6 +55,14 @@ class PythonServerImpl implements PythonServer, Disposable {
                 traceLog('Log:', message);
             }),
         );
+        this.pythonServer.on('exit', (code) => {
+            traceError(`Python server exited with code ${code}`);
+            this.markDisposed();
+        });
+        this.pythonServer.on('error', (err) => {
+            traceError(err);
+            this.markDisposed();
+        });
         this.connection.listen();
     }
 
@@ -75,12 +97,15 @@ class PythonServerImpl implements PythonServer, Disposable {
     }
 
     private async executeCode(code: string): Promise<ExecutionResult | undefined> {
+        this.inFlightRequests += 1;
         try {
             const result = await this.connection.sendRequest('execute', code);
             return result as ExecutionResult;
         } catch (err) {
             const error = err as Error;
             traceError(`Error getting response from REPL server:`, error);
+        } finally {
+            this.inFlightRequests -= 1;
         }
         return undefined;
     }
@@ -93,38 +118,47 @@ class PythonServerImpl implements PythonServer, Disposable {
     }
 
     public async checkValidCommand(code: string): Promise<boolean> {
-        const completeCode: ExecutionResult = await this.connection.sendRequest('check_valid_command', code);
-        if (completeCode.output === 'True') {
-            return new Promise((resolve) => resolve(true));
+        this.inFlightRequests += 1;
+        try {
+            const completeCode: ExecutionResult = await this.connection.sendRequest('check_valid_command', code);
+            return completeCode.output === 'True';
+        } finally {
+            this.inFlightRequests -= 1;
         }
-        return new Promise((resolve) => resolve(false));
     }
 
     public dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
         this.connection.sendNotification('exit');
         this.disposables.forEach((d) => d.dispose());
         this.connection.dispose();
+        serverInstance = undefined;
+    }
+
+    private markDisposed(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.connection.dispose();
+        serverInstance = undefined;
     }
 }
 
 export function createPythonServer(interpreter: string[], cwd?: string): PythonServer {
-    if (serverInstance) {
+    if (serverInstance && !serverInstance.isDisposed) {
         return serverInstance;
     }
 
     const pythonServer = ch.spawn(interpreter[0], [...interpreter.slice(1), SERVER_PATH], {
         cwd, // Launch with correct workspace directory
     });
-
     pythonServer.stderr.on('data', (data) => {
         traceError(data.toString());
     });
-    pythonServer.on('exit', (code) => {
-        traceError(`Python server exited with code ${code}`);
-    });
-    pythonServer.on('error', (err) => {
-        traceError(err);
-    });
     const connection = rpc.createMessageConnection(
         new rpc.StreamMessageReader(pythonServer.stdout),
         new rpc.StreamMessageWriter(pythonServer.stdin),
diff --git a/src/client/repl/replCommandHandler.ts b/src/client/repl/replCommandHandler.ts
index 89ccbe11c337..630eddfdd565 100644
--- a/src/client/repl/replCommandHandler.ts
+++ b/src/client/repl/replCommandHandler.ts
@@ -1,7 +1,4 @@
 import {
-    commands,
-    window,
-    NotebookController,
     NotebookEditor,
     ViewColumn,
     NotebookDocument,
@@ -9,34 +6,37 @@ import {
     NotebookCellKind,
     NotebookEdit,
     WorkspaceEdit,
-    workspace,
     Uri,
 } from 'vscode';
 import { getExistingReplViewColumn, getTabNameForUri } from './replUtils';
-import { PVSC_EXTENSION_ID } from '../common/constants';
+import { showNotebookDocument } from '../common/vscodeApis/windowApis';
+import { openNotebookDocument, applyEdit } from '../common/vscodeApis/workspaceApis';
+import { executeCommand } from '../common/vscodeApis/commandApis';
 
 /**
  * Function that opens/show REPL using IW UI.
  */
 export async function openInteractiveREPL(
-    notebookController: NotebookController,
     notebookDocument: NotebookDocument | Uri | undefined,
     preserveFocus: boolean = true,
-): Promise<NotebookEditor | undefined> {
+): Promise<{ notebookEditor: NotebookEditor; documentCreated: boolean } | undefined> {
     let viewColumn = ViewColumn.Beside;
+    let alreadyExists = false;
     if (notebookDocument instanceof Uri) {
         // Case where NotebookDocument is undefined, but workspace mementoURI exists.
-        notebookDocument = await workspace.openNotebookDocument(notebookDocument);
+        notebookDocument = await openNotebookDocument(notebookDocument);
     } else if (notebookDocument) {
         // Case where NotebookDocument (REPL document already exists in the tab)
         const existingReplViewColumn = getExistingReplViewColumn(notebookDocument);
         viewColumn = existingReplViewColumn ?? viewColumn;
+        alreadyExists = true;
     } else if (!notebookDocument) {
         // Case where NotebookDocument doesnt exist, or
         // became outdated (untitled.ipynb created without Python extension knowing, effectively taking over original Python REPL's URI)
-        notebookDocument = await workspace.openNotebookDocument('jupyter-notebook');
+        notebookDocument = await openNotebookDocument('jupyter-notebook');
     }
-    const editor = await window.showNotebookDocument(notebookDocument!, {
+
+    const notebookEditor = await showNotebookDocument(notebookDocument!, {
         viewColumn,
         asRepl: 'Python REPL',
         preserveFocus,
@@ -44,21 +44,15 @@ export async function openInteractiveREPL(
 
     // Sanity check that we opened a Native REPL from showNotebookDocument.
     if (
-        !editor ||
-        !editor.notebook ||
-        !editor.notebook.uri ||
-        getTabNameForUri(editor.notebook.uri) !== 'Python REPL'
+        !notebookEditor ||
+        !notebookEditor.notebook ||
+        !notebookEditor.notebook.uri ||
+        getTabNameForUri(notebookEditor.notebook.uri) !== 'Python REPL'
     ) {
         return undefined;
     }
 
-    await commands.executeCommand('notebook.selectKernel', {
-        editor,
-        id: notebookController.id,
-        extension: PVSC_EXTENSION_ID,
-    });
-
-    return editor;
+    return { notebookEditor, documentCreated: !alreadyExists };
 }
 
 /**
@@ -69,7 +63,7 @@ export async function selectNotebookKernel(
     notebookControllerId: string,
     extensionId: string,
 ): Promise<void> {
-    await commands.executeCommand('notebook.selectKernel', {
+    await executeCommand('notebook.selectKernel', {
         notebookEditor,
         id: notebookControllerId,
         extension: extensionId,
@@ -84,7 +78,7 @@ export async function executeNotebookCell(notebookEditor: NotebookEditor, code:
     const cellIndex = replOptions?.appendIndex ?? notebook.cellCount;
     await addCellToNotebook(notebook, cellIndex, code);
     // Execute the cell
-    commands.executeCommand('notebook.cell.execute', {
+    executeCommand('notebook.cell.execute', {
         ranges: [{ start: cellIndex, end: cellIndex + 1 }],
         document: notebook.uri,
     });
@@ -100,5 +94,5 @@ async function addCellToNotebook(notebookDocument: NotebookDocument, index: numb
     const notebookEdit = NotebookEdit.insertCells(index, [notebookCellData]);
     const workspaceEdit = new WorkspaceEdit();
     workspaceEdit.set(notebookDocument!.uri, [notebookEdit]);
-    await workspace.applyEdit(workspaceEdit);
+    await applyEdit(workspaceEdit);
 }
diff --git a/src/client/repl/replCommands.ts b/src/client/repl/replCommands.ts
index f260185988a8..1171e9466ee8 100644
--- a/src/client/repl/replCommands.ts
+++ b/src/client/repl/replCommands.ts
@@ -2,7 +2,6 @@ import { commands, Uri, window } from 'vscode';
 import { Disposable } from 'vscode-jsonrpc';
 import { ICommandManager } from '../common/application/types';
 import { Commands } from '../common/constants';
-import { noop } from '../common/utils/misc';
 import { IInterpreterService } from '../interpreter/contracts';
 import { ICodeExecutionHelper } from '../terminals/types';
 import { getNativeRepl } from './nativeRepl';
@@ -31,10 +30,8 @@ export async function registerStartNativeReplCommand(
             sendTelemetryEvent(EventName.REPL, undefined, { replType: 'Native' });
             const interpreter = await getActiveInterpreter(uri, interpreterService);
             if (interpreter) {
-                if (interpreter) {
-                    const nativeRepl = await getNativeRepl(interpreter, disposables);
-                    await nativeRepl.sendToNativeRepl(undefined, false);
-                }
+                const nativeRepl = await getNativeRepl(interpreter, disposables);
+                await nativeRepl.sendToNativeRepl(undefined, false);
             }
         }),
     );
@@ -104,14 +101,13 @@ export async function registerReplExecuteOnEnter(
 }
 
 async function onInputEnter(
-    uri: Uri,
+    uri: Uri | undefined,
     commandName: string,
     interpreterService: IInterpreterService,
     disposables: Disposable[],
 ): Promise<void> {
-    const interpreter = await interpreterService.getActiveInterpreter(uri);
+    const interpreter = await getActiveInterpreter(uri, interpreterService);
     if (!interpreter) {
-        commands.executeCommand(Commands.TriggerEnvironmentSelection, uri).then(noop, noop);
         return;
     }
 
diff --git a/src/client/repl/replUtils.ts b/src/client/repl/replUtils.ts
index 8e23218c2870..93ae6f2a4573 100644
--- a/src/client/repl/replUtils.ts
+++ b/src/client/repl/replUtils.ts
@@ -66,12 +66,13 @@ export function isMultiLineText(textEditor: TextEditor): boolean {
  * Function will also return undefined or active interpreter
  */
 export async function getActiveInterpreter(
-    uri: Uri,
+    uri: Uri | undefined,
     interpreterService: IInterpreterService,
 ): Promise<PythonEnvironment | undefined> {
-    const interpreter = await interpreterService.getActiveInterpreter(uri);
+    const resource = uri ?? getActiveResource();
+    const interpreter = await interpreterService.getActiveInterpreter(resource);
     if (!interpreter) {
-        commands.executeCommand(Commands.TriggerEnvironmentSelection, uri).then(noop, noop);
+        commands.executeCommand(Commands.TriggerEnvironmentSelection, resource).then(noop, noop);
         return undefined;
     }
     return interpreter;
diff --git a/src/client/startupTelemetry.ts b/src/client/startupTelemetry.ts
index 544fb24251ef..f7a2a6aea517 100644
--- a/src/client/startupTelemetry.ts
+++ b/src/client/startupTelemetry.ts
@@ -16,6 +16,7 @@ import { sendTelemetryEvent } from './telemetry';
 import { EventName } from './telemetry/constants';
 import { EditorLoadTelemetry } from './telemetry/types';
 import { IStartupDurations } from './types';
+import { useEnvExtension } from './envExt/api.internal';
 
 export async function sendStartupTelemetry(
     activatedPromise: Promise<any>,
@@ -105,9 +106,19 @@ async function getActivationTelemetryProps(
     // finish. API getActiveInterpreter() does not block on windows registry by default as
     // it is slow.
     await interpreterService.refreshPromise;
-    const interpreter = await interpreterService
-        .getActiveInterpreter()
-        .catch<PythonEnvironment | undefined>(() => undefined);
+    let interpreter: PythonEnvironment | undefined;
+
+    // include main workspace uri if using env extension
+    if (useEnvExtension()) {
+        interpreter = await interpreterService
+            .getActiveInterpreter(mainWorkspaceUri)
+            .catch<PythonEnvironment | undefined>(() => undefined);
+    } else {
+        interpreter = await interpreterService
+            .getActiveInterpreter()
+            .catch<PythonEnvironment | undefined>(() => undefined);
+    }
+
     const pythonVersion = interpreter && interpreter.version ? interpreter.version.raw : undefined;
     const interpreterType = interpreter ? interpreter.envType : undefined;
     if (interpreterType === EnvironmentType.Unknown) {
@@ -125,6 +136,7 @@ async function getActivationTelemetryProps(
     const usingGlobalInterpreter = interpreter
         ? isUsingGlobalInterpreterInWorkspace(interpreter.path, serviceContainer)
         : false;
+    const usingEnvironmentsExtension = useEnvExtension();
 
     return {
         condaVersion,
@@ -137,5 +149,6 @@ async function getActivationTelemetryProps(
         usingGlobalInterpreter,
         appName,
         isFirstSession,
+        usingEnvironmentsExtension,
     };
 }
diff --git a/src/client/telemetry/constants.ts b/src/client/telemetry/constants.ts
index ecc44177338a..eff32a6e3299 100644
--- a/src/client/telemetry/constants.ts
+++ b/src/client/telemetry/constants.ts
@@ -7,6 +7,7 @@ export enum EventName {
     FORMAT_ON_TYPE = 'FORMAT.FORMAT_ON_TYPE',
     EDITOR_LOAD = 'EDITOR.LOAD',
     REPL = 'REPL',
+    INVOKE_TOOL = 'INVOKE_TOOL',
     CREATE_NEW_FILE_COMMAND = 'CREATE_NEW_FILE_COMMAND',
     SELECT_INTERPRETER = 'SELECT_INTERPRETER',
     SELECT_INTERPRETER_ENTER_BUTTON = 'SELECT_INTERPRETER_ENTER_BUTTON',
diff --git a/src/client/telemetry/index.ts b/src/client/telemetry/index.ts
index 6c97bd083d96..763f7405aa0d 100644
--- a/src/client/telemetry/index.ts
+++ b/src/client/telemetry/index.ts
@@ -404,6 +404,10 @@ export interface IEventNamePropertyMapping {
          * to approximately guess if it's the first session.
          */
         isFirstSession?: boolean;
+        /**
+         * If user has enabled the Python Environments extension integration
+         */
+        usingEnvironmentsExtension?: boolean;
     };
     /**
      * Telemetry event sent when substituting Environment variables to calculate value of variables
@@ -1980,6 +1984,57 @@ export interface IEventNamePropertyMapping {
          */
         replType: 'Terminal' | 'Native' | 'manualTerminal' | `runningScript`;
     };
+    /**
+     * Telemetry event sent when invoking a Tool
+     */
+    /* __GDPR__
+       "INVOKE_TOOL" : {
+           "duration" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true, "owner": "donjayamanne" },
+           "toolName" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "owner": "donjayamanne" },
+            "failed": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"Whether there was a failure. Common to most of the events.", "owner": "donjayamanne" },
+            "failureCategory": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"A reason that we generate (e.g. kerneldied, noipykernel, etc), more like a category of the error. Common to most of the events.", "owner": "donjayamanne" },
+            "resolveOutcome": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"Which code path resolved the environment in configure_python_environment.", "owner": "donjayamanne" },
+            "envType": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"The type of Python environment (e.g. venv, conda, system).", "owner": "donjayamanne" },
+            "packageCount": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"Number of packages requested for installation (install_python_packages only).", "owner": "donjayamanne" },
+            "installerType": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"Which installer was used: pip or conda (install_python_packages only).", "owner": "donjayamanne" },
+            "responsePackageCount": {"classification":"SystemMetaData","purpose":"FeatureInsight","comment":"Number of packages in the environment response (get_python_environment_details only).", "owner": "donjayamanne" }
+       }
+     */
+    [EventName.INVOKE_TOOL]: {
+        /**
+         * Tool name.
+         */
+        toolName: string;
+        /**
+         * Whether there was a failure.
+         * Common to most of the events.
+         */
+        failed: boolean;
+        /**
+         * A reason the error was thrown.
+         */
+        failureCategory?: string;
+        /**
+         * Which code path resolved the environment (configure_python_environment only).
+         */
+        resolveOutcome?: string;
+        /**
+         * The type of Python environment (e.g. venv, conda, system).
+         */
+        envType?: string;
+        /**
+         * Number of packages requested for installation (install_python_packages only).
+         */
+        packageCount?: string;
+        /**
+         * Which installer was used: pip or conda (install_python_packages only).
+         */
+        installerType?: string;
+        /**
+         * Number of packages in the environment response (get_python_environment_details only).
+         */
+        responsePackageCount?: string;
+    };
     /**
      * Telemetry event sent if and when user configure tests command. This command can be trigerred from multiple places in the extension. (Command palette, prompt etc.)
      */
@@ -2310,7 +2365,7 @@ export interface IEventNamePropertyMapping {
        }
      */
     [EventName.ENVIRONMENT_CREATING]: {
-        environmentType: 'venv' | 'conda' | 'microvenv';
+        environmentType: 'venv' | 'conda' | 'microvenv' | undefined;
         pythonVersion: string | undefined;
     };
     /**
diff --git a/src/client/telemetry/pylance.ts b/src/client/telemetry/pylance.ts
index 42d177488790..63bd113893e2 100644
--- a/src/client/telemetry/pylance.ts
+++ b/src/client/telemetry/pylance.ts
@@ -148,6 +148,32 @@
       "failed" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
    }
 */
+/* __GDPR__
+   "language_server/completion_context_items" : {
+      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "context" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+      "count" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+   }
+*/
+/* __GDPR__
+   "language_server/documentcolor_slow" : {
+      "bindcallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "bindtime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "parsecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "parsetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "readfilecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "readfiletime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "resolvecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "resolvetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "tokenizecallcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "tokenizetime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "totaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "typeevalcount" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "typeevaltime" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "failed" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
+   }
+*/
 /* __GDPR__
    "language_server/exception_intellicode" : {
       "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
@@ -352,6 +378,9 @@
    "language_server/settings" : {
       "addimportexactmatchonly" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
       "aicodeactionsimplementabstractclasses" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+      "aiCodeActionsGenerateDocstring" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+      "aiCodeActionsGenerateSymbols" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+      "aiCodeActionsConvertFormatString" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
       "autoimportcompletions" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
       "autosearchpaths" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
       "callArgumentNameInlayHints" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
@@ -428,6 +457,21 @@
       "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
    }
 */
+/* __GDPR__
+   "language_server/mcp_tool" : {
+      "kind" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "duration" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "cancelled" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "cancellation_reason" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "lsversion" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+      "failed" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
+   }
+*/
+/* __GDPR__
+   "language_server/copilot_hover" : {
+      "symbolName" : { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
+   }
+*/
 /**
  * Telemetry event sent when LSP server crashes
  */
diff --git a/src/client/terminals/activation.ts b/src/client/terminals/activation.ts
index 143a2de14e5c..ed26916e3eaa 100644
--- a/src/client/terminals/activation.ts
+++ b/src/client/terminals/activation.ts
@@ -9,6 +9,7 @@ import { IActiveResourceService, ITerminalManager } from '../common/application/
 import { ITerminalActivator } from '../common/terminal/types';
 import { IDisposable, IDisposableRegistry } from '../common/types';
 import { ITerminalAutoActivation } from './types';
+import { shouldEnvExtHandleActivation } from '../envExt/api.internal';
 
 @injectable()
 export class TerminalAutoActivation implements ITerminalAutoActivation {
@@ -49,6 +50,9 @@ export class TerminalAutoActivation implements ITerminalAutoActivation {
         if (this.terminalsNotToAutoActivate.has(terminal)) {
             return;
         }
+        if (shouldEnvExtHandleActivation()) {
+            return;
+        }
         if ('hideFromUser' in terminal.creationOptions && terminal.creationOptions.hideFromUser) {
             return;
         }
diff --git a/src/client/terminals/codeExecution/codeExecutionManager.ts b/src/client/terminals/codeExecution/codeExecutionManager.ts
index b1dc328d137e..48165adcd169 100644
--- a/src/client/terminals/codeExecution/codeExecutionManager.ts
+++ b/src/client/terminals/codeExecution/codeExecutionManager.ts
@@ -5,7 +5,7 @@
 
 import { inject, injectable } from 'inversify';
 import { Disposable, EventEmitter, Terminal, Uri } from 'vscode';
-
+import * as path from 'path';
 import { ICommandManager, IDocumentManager } from '../../common/application/types';
 import { Commands } from '../../common/constants';
 import '../../common/extensions';
@@ -41,6 +41,8 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                 this.disposableRegistry.push(
                     this.commandManager.registerCommand(cmd as any, async (file: Resource) => {
                         traceVerbose(`Attempting to run Python file`, file?.fsPath);
+                        const trigger = cmd === Commands.Exec_In_Terminal ? 'command' : 'icon';
+                        const newTerminalPerFile = cmd === Commands.Exec_In_Separate_Terminal;
 
                         if (useEnvExtension()) {
                             try {
@@ -48,6 +50,14 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                             } catch (ex) {
                                 traceError('Failed to execute file in terminal', ex);
                             }
+                            sendTelemetryEvent(EventName.ENVIRONMENT_CHECK_TRIGGER, undefined, {
+                                trigger: 'run-in-terminal',
+                            });
+                            sendTelemetryEvent(EventName.EXECUTION_CODE, undefined, {
+                                scope: 'file',
+                                trigger,
+                                newTerminalPerFile,
+                            });
                             return;
                         }
 
@@ -63,9 +73,9 @@ export class CodeExecutionManager implements ICodeExecutionManager {
                             trigger: 'run-in-terminal',
                         });
                         triggerCreateEnvironmentCheckNonBlocking(CreateEnvironmentCheckKind.File, file);
-                        const trigger = cmd === Commands.Exec_In_Terminal ? 'command' : 'icon';
+
                         await this.executeFileInTerminal(file, trigger, {
-                            newTerminalPerFile: cmd === Commands.Exec_In_Separate_Terminal,
+                            newTerminalPerFile,
                         })
                             .then(() => {
                                 if (this.shouldTerminalFocusOnStart(file))
@@ -120,27 +130,26 @@ export class CodeExecutionManager implements ICodeExecutionManager {
         if (!fileToExecute) {
             return;
         }
+
         const fileAfterSave = await codeExecutionHelper.saveFileIfDirty(fileToExecute);
         if (fileAfterSave) {
             fileToExecute = fileAfterSave;
         }
 
+        // Check on setting terminal.executeInFileDir
+        const pythonSettings = this.configSettings.getSettings(file);
+        let cwd = pythonSettings.terminal.executeInFileDir ? path.dirname(fileToExecute.fsPath) : undefined;
+
+        // Check on setting terminal.launchArgs
+        const launchArgs = pythonSettings.terminal.launchArgs;
+        const totalArgs = [...launchArgs, fileToExecute.fsPath.fileToCommandArgumentForPythonExt()];
+
         const show = this.shouldTerminalFocusOnStart(fileToExecute);
         let terminal: Terminal | undefined;
         if (dedicated) {
-            terminal = await runInDedicatedTerminal(
-                fileToExecute,
-                [fileToExecute.fsPath.fileToCommandArgumentForPythonExt()],
-                undefined,
-                show,
-            );
+            terminal = await runInDedicatedTerminal(fileToExecute, totalArgs, cwd, show);
         } else {
-            terminal = await runInTerminal(
-                fileToExecute,
-                [fileToExecute.fsPath.fileToCommandArgumentForPythonExt()],
-                undefined,
-                show,
-            );
+            terminal = await runInTerminal(fileToExecute, totalArgs, cwd, show);
         }
 
         if (terminal) {
diff --git a/src/client/terminals/codeExecution/helper.ts b/src/client/terminals/codeExecution/helper.ts
index 31a626207bc4..4efad5ee174e 100644
--- a/src/client/terminals/codeExecution/helper.ts
+++ b/src/client/terminals/codeExecution/helper.ts
@@ -55,7 +55,7 @@ export class CodeExecutionHelper implements ICodeExecutionHelper {
 
     public async normalizeLines(
         code: string,
-        replType: ReplType,
+        _replType: ReplType,
         wholeFileContent?: string,
         resource?: Uri,
     ): Promise<string> {
@@ -99,10 +99,12 @@ export class CodeExecutionHelper implements ICodeExecutionHelper {
             const endLineVal = activeEditor?.selection?.end.line ?? 0;
             const emptyHighlightVal = activeEditor?.selection?.isEmpty ?? true;
             let smartSendSettingsEnabledVal = true;
+            let shellIntegrationEnabled = false;
             const configuration = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
             if (configuration) {
                 const pythonSettings = configuration.getSettings(this.activeResourceService.getActiveResource());
                 smartSendSettingsEnabledVal = pythonSettings.REPL.enableREPLSmartSend;
+                shellIntegrationEnabled = pythonSettings.terminal.shellIntegration.enabled;
             }
 
             const input = JSON.stringify({
@@ -124,8 +126,9 @@ export class CodeExecutionHelper implements ICodeExecutionHelper {
                 const lineOffset = object.nextBlockLineno - activeEditor!.selection.start.line - 1;
                 await this.moveToNextBlock(lineOffset, activeEditor);
             }
-            // For new _pyrepl for Python3.13 and above, we need to send code via bracketed paste mode.
-            if (object.attach_bracket_paste && replType === ReplType.terminal) {
+
+            // For new _pyrepl for Python3.13+ && !shellIntegration, we need to send code via bracketed paste mode.
+            if (object.attach_bracket_paste && !shellIntegrationEnabled && _replType === ReplType.terminal) {
                 let trimmedNormalized = object.normalized.replace(/\n$/, '');
                 if (trimmedNormalized.endsWith(':\n')) {
                     // In case where statement is unfinished via :, truncate so auto-indentation lands nicely.
diff --git a/src/client/terminals/envCollectionActivation/service.ts b/src/client/terminals/envCollectionActivation/service.ts
index 43b8ceeb8e06..2ce8d5d5d86a 100644
--- a/src/client/terminals/envCollectionActivation/service.ts
+++ b/src/client/terminals/envCollectionActivation/service.ts
@@ -44,6 +44,7 @@ import {
 } from '../types';
 import { ProgressService } from '../../common/application/progressService';
 import { useEnvExtension } from '../../envExt/api.internal';
+import { registerPythonStartup } from '../pythonStartup';
 
 @injectable()
 export class TerminalEnvVarCollectionService implements IExtensionActivationService, ITerminalEnvVarCollectionService {
@@ -96,6 +97,14 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
 
     public async activate(resource: Resource): Promise<void> {
         try {
+            if (useEnvExtension()) {
+                traceVerbose('Ignoring environment variable experiment since env extension is being used');
+                this.context.environmentVariableCollection.clear();
+                // Needed for shell integration
+                await registerPythonStartup(this.context);
+                return;
+            }
+
             if (!inTerminalEnvVarExperiment(this.experimentService)) {
                 this.context.environmentVariableCollection.clear();
                 await this.handleMicroVenv(resource);
@@ -109,6 +118,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                     );
                     this.registeredOnce = true;
                 }
+                await registerPythonStartup(this.context);
                 return;
             }
             if (!this.registeredOnce) {
diff --git a/src/client/terminals/envCollectionActivation/shellIntegrationService.ts b/src/client/terminals/envCollectionActivation/shellIntegrationService.ts
index 71cfb18dd437..92bb98029892 100644
--- a/src/client/terminals/envCollectionActivation/shellIntegrationService.ts
+++ b/src/client/terminals/envCollectionActivation/shellIntegrationService.ts
@@ -15,6 +15,7 @@ import { IDisposableRegistry, IPersistentStateFactory } from '../../common/types
 import { sleep } from '../../common/utils/async';
 import { traceError, traceVerbose } from '../../logging';
 import { IShellIntegrationDetectionService } from '../types';
+import { isTrusted } from '../../common/vscodeApis/workspaceApis';
 
 /**
  * This is a list of shells which support shell integration:
@@ -151,10 +152,12 @@ export class ShellIntegrationDetectionService implements IShellIntegrationDetect
      * Creates a dummy terminal so that we are guaranteed a data write event for this shell type.
      */
     private createDummyHiddenTerminal(shell: string) {
-        this.terminalManager.createTerminal({
-            shellPath: shell,
-            hideFromUser: true,
-        });
+        if (isTrusted()) {
+            this.terminalManager.createTerminal({
+                shellPath: shell,
+                hideFromUser: true,
+            });
+        }
     }
 }
 
diff --git a/src/client/terminals/pythonStartup.ts b/src/client/terminals/pythonStartup.ts
index 28878713a8db..b6f68c860b46 100644
--- a/src/client/terminals/pythonStartup.ts
+++ b/src/client/terminals/pythonStartup.ts
@@ -1,10 +1,11 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { ExtensionContext, Uri } from 'vscode';
+import { ExtensionContext, MarkdownString, Uri } from 'vscode';
 import * as path from 'path';
 import { copy, createDirectory, getConfiguration, onDidChangeConfiguration } from '../common/vscodeApis/workspaceApis';
 import { EXTENSION_ROOT_DIR } from '../constants';
+import { Interpreters } from '../common/utils/localize';
 
 async function applyPythonStartupSetting(context: ExtensionContext): Promise<void> {
     const config = getConfiguration('python');
@@ -21,8 +22,17 @@ async function applyPythonStartupSetting(context: ExtensionContext): Promise<voi
         const sourcePath = path.join(EXTENSION_ROOT_DIR, 'python_files', 'pythonrc.py');
         await copy(Uri.file(sourcePath), destPath, { overwrite: true });
         context.environmentVariableCollection.replace('PYTHONSTARTUP', destPath.fsPath);
+        // When shell integration is enabled, we disable PyREPL from cpython.
+        context.environmentVariableCollection.replace('PYTHON_BASIC_REPL', '1');
+        context.environmentVariableCollection.description = new MarkdownString(
+            Interpreters.shellIntegrationEnvVarCollectionDescription,
+        );
     } else {
         context.environmentVariableCollection.delete('PYTHONSTARTUP');
+        context.environmentVariableCollection.delete('PYTHON_BASIC_REPL');
+        context.environmentVariableCollection.description = new MarkdownString(
+            Interpreters.shellIntegrationDisabledEnvVarCollectionDescription,
+        );
     }
 }
 
diff --git a/src/client/testing/common/debugLauncher.ts b/src/client/testing/common/debugLauncher.ts
index c28535b30644..037bfb265088 100644
--- a/src/client/testing/common/debugLauncher.ts
+++ b/src/client/testing/common/debugLauncher.ts
@@ -1,6 +1,6 @@
 import { inject, injectable, named } from 'inversify';
 import * as path from 'path';
-import { DebugConfiguration, l10n, Uri, WorkspaceFolder, DebugSession, DebugSessionOptions } from 'vscode';
+import { DebugConfiguration, l10n, Uri, WorkspaceFolder, DebugSession, DebugSessionOptions, Disposable } from 'vscode';
 import { IApplicationShell, IDebugService } from '../../common/application/types';
 import { EXTENSION_ROOT_DIR } from '../../common/constants';
 import * as internalScripts from '../../common/process/internal/scripts';
@@ -17,6 +17,14 @@ import { getWorkspaceFolder, getWorkspaceFolders } from '../../common/vscodeApis
 import { showErrorMessage } from '../../common/vscodeApis/windowApis';
 import { createDeferred } from '../../common/utils/async';
 import { addPathToPythonpath } from './helpers';
+import * as envExtApi from '../../envExt/api.internal';
+
+/**
+ * Key used to mark debug configurations with a unique session identifier.
+ * This allows us to track which debug session belongs to which launchDebugger() call
+ * when multiple debug sessions are launched in parallel.
+ */
+const TEST_SESSION_MARKER_KEY = '__vscodeTestSessionMarker';
 
 @injectable()
 export class DebugLauncher implements ITestDebugLauncher {
@@ -31,6 +39,10 @@ export class DebugLauncher implements ITestDebugLauncher {
         this.configService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
     }
 
+    /**
+     * Launches a debug session for test execution.
+     * Handles cancellation, multi-session support via unique markers, and cleanup.
+     */
     public async launchDebugger(
         options: LaunchOptions,
         callback?: () => void,
@@ -38,18 +50,35 @@ export class DebugLauncher implements ITestDebugLauncher {
     ): Promise<void> {
         const deferred = createDeferred<void>();
         let hasCallbackBeenCalled = false;
+
+        // Collect disposables for cleanup when debugging completes
+        const disposables: Disposable[] = [];
+
+        // Ensure callback is only invoked once, even if multiple termination paths fire
+        const callCallbackOnce = () => {
+            if (!hasCallbackBeenCalled) {
+                hasCallbackBeenCalled = true;
+                callback?.();
+            }
+        };
+
+        // Early exit if already cancelled before we start
         if (options.token && options.token.isCancellationRequested) {
-            hasCallbackBeenCalled = true;
-            return undefined;
+            callCallbackOnce();
             deferred.resolve();
-            callback?.();
+            return deferred.promise;
         }
 
-        options.token?.onCancellationRequested(() => {
-            deferred.resolve();
-            callback?.();
-            hasCallbackBeenCalled = true;
-        });
+        // Listen for cancellation from the test run (e.g., user clicks stop in Test Explorer)
+        // This allows the caller to clean up resources even if the debug session is still running
+        if (options.token) {
+            disposables.push(
+                options.token.onCancellationRequested(() => {
+                    deferred.resolve();
+                    callCallbackOnce();
+                }),
+            );
+        }
 
         const workspaceFolder = DebugLauncher.resolveWorkspaceFolder(options.cwd);
         const launchArgs = await this.getLaunchArgs(
@@ -59,23 +88,57 @@ export class DebugLauncher implements ITestDebugLauncher {
         );
         const debugManager = this.serviceContainer.get<IDebugService>(IDebugService);
 
-        let activatedDebugSession: DebugSession | undefined;
-        debugManager.startDebugging(workspaceFolder, launchArgs, sessionOptions).then(() => {
-            // Save the debug session after it is started so we can check if it is the one that was terminated.
-            activatedDebugSession = debugManager.activeDebugSession;
-        });
-        debugManager.onDidTerminateDebugSession((session) => {
-            traceVerbose(`Debug session terminated. sessionId: ${session.id}`);
-            // Only resolve no callback has been made and the session is the one that was started.
-            if (
-                !hasCallbackBeenCalled &&
-                activatedDebugSession !== undefined &&
-                session.id === activatedDebugSession?.id
-            ) {
-                deferred.resolve();
-                callback?.();
-            }
+        // Unique marker to identify this session among concurrent debug sessions
+        const sessionMarker = `test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        launchArgs[TEST_SESSION_MARKER_KEY] = sessionMarker;
+
+        let ourSession: DebugSession | undefined;
+
+        // Capture our specific debug session when it starts by matching the marker.
+        // This fires for ALL debug sessions, so we filter to only our marker.
+        disposables.push(
+            debugManager.onDidStartDebugSession((session) => {
+                if (session.configuration[TEST_SESSION_MARKER_KEY] === sessionMarker) {
+                    ourSession = session;
+                    traceVerbose(`[test-debug] Debug session started: ${session.name} (${session.id})`);
+                }
+            }),
+        );
+
+        // Handle debug session termination (user stops debugging, or tests complete).
+        // Only react to OUR session terminating - other parallel sessions should
+        // continue running independently.
+        disposables.push(
+            debugManager.onDidTerminateDebugSession((session) => {
+                if (ourSession && session.id === ourSession.id) {
+                    traceVerbose(`[test-debug] Debug session terminated: ${session.name} (${session.id})`);
+                    deferred.resolve();
+                    callCallbackOnce();
+                }
+            }),
+        );
+
+        // Clean up event subscriptions when debugging completes (success, failure, or cancellation)
+        deferred.promise.finally(() => {
+            disposables.forEach((d) => d.dispose());
         });
+
+        // Start the debug session
+        let started = false;
+        try {
+            started = await debugManager.startDebugging(workspaceFolder, launchArgs, sessionOptions);
+        } catch (error) {
+            traceError('Error starting debug session', error);
+            deferred.reject(error);
+            callCallbackOnce();
+            return deferred.promise;
+        }
+        if (!started) {
+            traceError('Failed to start debug session');
+            deferred.resolve();
+            callCallbackOnce();
+        }
+
         return deferred.promise;
     }
 
@@ -108,6 +171,12 @@ export class DebugLauncher implements ITestDebugLauncher {
                 subProcess: true,
             };
         }
+
+        // Use project name in debug session name if provided
+        if (options.project) {
+            debugConfig.name = `Debug Tests: ${options.project.name}`;
+        }
+
         if (!debugConfig.rules) {
             debugConfig.rules = [];
         }
@@ -116,7 +185,7 @@ export class DebugLauncher implements ITestDebugLauncher {
             include: false,
         });
 
-        DebugLauncher.applyDefaults(debugConfig!, workspaceFolder, configSettings);
+        DebugLauncher.applyDefaults(debugConfig!, workspaceFolder, configSettings, options.cwd);
 
         return this.convertConfigToArgs(debugConfig!, workspaceFolder, options);
     }
@@ -163,6 +232,7 @@ export class DebugLauncher implements ITestDebugLauncher {
         cfg: LaunchRequestArguments,
         workspaceFolder: WorkspaceFolder,
         configSettings: IPythonSettings,
+        optionsCwd?: string,
     ) {
         // cfg.pythonPath is handled by LaunchConfigurationResolver.
 
@@ -170,7 +240,9 @@ export class DebugLauncher implements ITestDebugLauncher {
             cfg.console = 'internalConsole';
         }
         if (!cfg.cwd) {
-            cfg.cwd = configSettings.testing.cwd || workspaceFolder.uri.fsPath;
+            // For project-based testing, use the project's cwd (optionsCwd) if provided.
+            // Otherwise fall back to settings.testing.cwd or the workspace folder.
+            cfg.cwd = optionsCwd || configSettings.testing.cwd || workspaceFolder.uri.fsPath;
         }
         if (!cfg.env) {
             cfg.env = {};
@@ -257,6 +329,23 @@ export class DebugLauncher implements ITestDebugLauncher {
         // run via F5 style debugging.
         launchArgs.purpose = [];
 
+        // For project-based execution, get the Python path from the project's environment.
+        // Fallback: if env API unavailable or fails, LaunchConfigurationResolver already set
+        // launchArgs.python from the active interpreter, so debugging still works.
+        if (options.project && envExtApi.useEnvExtension()) {
+            try {
+                const pythonEnv = await envExtApi.getEnvironment(options.project.uri);
+                if (pythonEnv?.execInfo?.run?.executable) {
+                    launchArgs.python = pythonEnv.execInfo.run.executable;
+                    traceVerbose(
+                        `[test-by-project] Debug session using Python path from project: ${launchArgs.python}`,
+                    );
+                }
+            } catch (error) {
+                traceVerbose(`[test-by-project] Could not get environment for project, using default: ${error}`);
+            }
+        }
+
         return launchArgs;
     }
 
diff --git a/src/client/testing/common/types.ts b/src/client/testing/common/types.ts
index 17d528d234f9..e2fa2d6d2e5a 100644
--- a/src/client/testing/common/types.ts
+++ b/src/client/testing/common/types.ts
@@ -2,6 +2,7 @@ import { CancellationToken, DebugSessionOptions, OutputChannel, Uri } from 'vsco
 import { Product } from '../../common/types';
 import { TestSettingsPropertyNames } from '../configuration/types';
 import { TestProvider } from '../types';
+import { PythonProject } from '../../envExt/types';
 
 export type UnitTestProduct = Product.pytest | Product.unittest;
 
@@ -26,6 +27,8 @@ export type LaunchOptions = {
     pytestPort?: string;
     pytestUUID?: string;
     runTestIdsPort?: string;
+    /** Optional Python project for project-based execution. */
+    project?: PythonProject;
 };
 
 export enum TestFilter {
@@ -50,7 +53,6 @@ export interface ITestsHelper {
 export const ITestConfigurationService = Symbol('ITestConfigurationService');
 export interface ITestConfigurationService {
     hasConfiguredTests(wkspace: Uri): boolean;
-    displayTestFrameworkError(wkspace: Uri): Promise<void>;
     selectTestRunner(placeHolderMessage: string): Promise<UnitTestProduct | undefined>;
     enableTest(wkspace: Uri, product: UnitTestProduct): Promise<void>;
     promptToEnableAndConfigureTestFramework(wkspace: Uri): Promise<void>;
diff --git a/src/client/testing/configuration/index.ts b/src/client/testing/configuration/index.ts
index 4825e9aa4f6a..b78475293594 100644
--- a/src/client/testing/configuration/index.ts
+++ b/src/client/testing/configuration/index.ts
@@ -40,28 +40,6 @@ export class UnitTestConfigurationService implements ITestConfigurationService {
         return settings.testing.pytestEnabled || settings.testing.unittestEnabled || false;
     }
 
-    public async displayTestFrameworkError(wkspace: Uri): Promise<void> {
-        const settings = this.configurationService.getSettings(wkspace);
-        let enabledCount = settings.testing.pytestEnabled ? 1 : 0;
-        enabledCount += settings.testing.unittestEnabled ? 1 : 0;
-        if (enabledCount > 1) {
-            return this._promptToEnableAndConfigureTestFramework(
-                wkspace,
-                'Enable only one of the test frameworks (unittest or pytest).',
-                true,
-            );
-        }
-        const option = 'Enable and configure a Test Framework';
-        const item = await this.appShell.showInformationMessage(
-            'No test framework configured (unittest, or pytest)',
-            option,
-        );
-        if (item !== option) {
-            throw NONE_SELECTED;
-        }
-        return this._promptToEnableAndConfigureTestFramework(wkspace);
-    }
-
     public async selectTestRunner(placeHolderMessage: string): Promise<UnitTestProduct | undefined> {
         const items = [
             {
diff --git a/src/client/testing/configuration/pytest/testConfigurationManager.ts b/src/client/testing/configuration/pytest/testConfigurationManager.ts
index 89f4246346ef..08f88f8564c7 100644
--- a/src/client/testing/configuration/pytest/testConfigurationManager.ts
+++ b/src/client/testing/configuration/pytest/testConfigurationManager.ts
@@ -3,12 +3,19 @@ import { QuickPickItem, Uri } from 'vscode';
 import { IFileSystem } from '../../../common/platform/types';
 import { Product } from '../../../common/types';
 import { IServiceContainer } from '../../../ioc/types';
+import { IApplicationShell } from '../../../common/application/types';
 import { TestConfigurationManager } from '../../common/testConfigurationManager';
 import { ITestConfigSettingsService } from '../../common/types';
+import { PytestInstallationHelper } from '../pytestInstallationHelper';
+import { traceInfo } from '../../../logging';
 
 export class ConfigurationManager extends TestConfigurationManager {
+    private readonly pytestInstallationHelper: PytestInstallationHelper;
+
     constructor(workspace: Uri, serviceContainer: IServiceContainer, cfg?: ITestConfigSettingsService) {
         super(workspace, Product.pytest, serviceContainer, cfg);
+        const appShell = serviceContainer.get<IApplicationShell>(IApplicationShell);
+        this.pytestInstallationHelper = new PytestInstallationHelper(appShell);
     }
 
     public async requiresUserToConfigure(wkspace: Uri): Promise<boolean> {
@@ -42,10 +49,22 @@ export class ConfigurationManager extends TestConfigurationManager {
             args.push(testDir);
         }
         const installed = await this.installer.isInstalled(Product.pytest);
+        await this.testConfigSettingsService.updateTestArgs(wkspace.fsPath, Product.pytest, args);
         if (!installed) {
-            await this.installer.install(Product.pytest);
+            // Check if Python Environments extension is available for enhanced installation flow
+            if (this.pytestInstallationHelper.isEnvExtensionAvailable()) {
+                traceInfo('pytest not installed, prompting user with environment extension integration');
+                const installAttempted = await this.pytestInstallationHelper.promptToInstallPytest(wkspace);
+                if (!installAttempted) {
+                    // User chose to ignore or installation failed
+                    return;
+                }
+            } else {
+                // Fall back to traditional installer
+                traceInfo('pytest not installed, falling back to traditional installer');
+                await this.installer.install(Product.pytest);
+            }
         }
-        await this.testConfigSettingsService.updateTestArgs(wkspace.fsPath, Product.pytest, args);
     }
 
     private async getConfigFiles(rootDir: string): Promise<string[]> {
diff --git a/src/client/testing/configuration/pytestInstallationHelper.ts b/src/client/testing/configuration/pytestInstallationHelper.ts
new file mode 100644
index 000000000000..bd5fbcd5bb37
--- /dev/null
+++ b/src/client/testing/configuration/pytestInstallationHelper.ts
@@ -0,0 +1,95 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Uri, l10n } from 'vscode';
+import { IApplicationShell } from '../../common/application/types';
+import { traceInfo, traceError } from '../../logging';
+import { useEnvExtension, getEnvExtApi } from '../../envExt/api.internal';
+import { getEnvironment } from '../../envExt/api.internal';
+
+/**
+ * Helper class to handle pytest installation using the appropriate method
+ * based on whether the Python Environments extension is available.
+ */
+export class PytestInstallationHelper {
+    constructor(private readonly appShell: IApplicationShell) {}
+
+    /**
+     * Prompts the user to install pytest with appropriate installation method.
+     * @param workspaceUri The workspace URI where pytest should be installed
+     * @returns Promise that resolves to true if installation was attempted, false otherwise
+     */
+    async promptToInstallPytest(workspaceUri: Uri): Promise<boolean> {
+        const message = l10n.t('pytest selected but not installed. Would you like to install pytest?');
+        const installOption = l10n.t('Install pytest');
+
+        const selection = await this.appShell.showInformationMessage(message, { modal: true }, installOption);
+
+        if (selection === installOption) {
+            return this.installPytest(workspaceUri);
+        }
+
+        return false;
+    }
+
+    /**
+     * Installs pytest using the appropriate method based on available extensions.
+     * @param workspaceUri The workspace URI where pytest should be installed
+     * @returns Promise that resolves to true if installation was successful, false otherwise
+     */
+    private async installPytest(workspaceUri: Uri): Promise<boolean> {
+        try {
+            if (useEnvExtension()) {
+                return this.installPytestWithEnvExtension(workspaceUri);
+            } else {
+                // Fall back to traditional installer if environments extension is not available
+                traceInfo(
+                    'Python Environments extension not available, installation cannot proceed via environment extension',
+                );
+                return false;
+            }
+        } catch (error) {
+            traceError('Error installing pytest:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Installs pytest using the Python Environments extension.
+     * @param workspaceUri The workspace URI where pytest should be installed
+     * @returns Promise that resolves to true if installation was successful, false otherwise
+     */
+    private async installPytestWithEnvExtension(workspaceUri: Uri): Promise<boolean> {
+        try {
+            const envExtApi = await getEnvExtApi();
+            const environment = await getEnvironment(workspaceUri);
+
+            if (!environment) {
+                traceError('No Python environment found for workspace:', workspaceUri.fsPath);
+                await this.appShell.showErrorMessage(
+                    l10n.t('No Python environment found. Please set up a Python environment first.'),
+                );
+                return false;
+            }
+
+            traceInfo('Installing pytest using Python Environments extension...');
+            await envExtApi.managePackages(environment, {
+                install: ['pytest'],
+            });
+
+            traceInfo('pytest installation completed successfully');
+            return true;
+        } catch (error) {
+            traceError('Failed to install pytest using Python Environments extension:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Checks if the Python Environments extension is available for package management.
+     * @returns True if the extension is available, false otherwise
+     */
+    isEnvExtensionAvailable(): boolean {
+        return useEnvExtension();
+    }
+}
diff --git a/src/client/testing/main.ts b/src/client/testing/main.ts
index c2675ed4a72b..eed4d70e852c 100644
--- a/src/client/testing/main.ts
+++ b/src/client/testing/main.ts
@@ -1,7 +1,16 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { ConfigurationChangeEvent, Disposable, Uri, tests, TestResultState, WorkspaceFolder, Command } from 'vscode';
+import {
+    ConfigurationChangeEvent,
+    Disposable,
+    Uri,
+    tests,
+    TestResultState,
+    WorkspaceFolder,
+    Command,
+    TestItem,
+} from 'vscode';
 import { IApplicationShell, ICommandManager, IContextKeyManager, IWorkspaceService } from '../common/application/types';
 import * as constants from '../common/constants';
 import '../common/extensions';
@@ -9,7 +18,7 @@ import { IDisposableRegistry, Product } from '../common/types';
 import { IInterpreterService } from '../interpreter/contracts';
 import { IServiceContainer } from '../ioc/types';
 import { EventName } from '../telemetry/constants';
-import { captureTelemetry, sendTelemetryEvent } from '../telemetry/index';
+import { sendTelemetryEvent } from '../telemetry/index';
 import { selectTestWorkspace } from './common/testUtils';
 import { TestSettingsPropertyNames } from './configuration/types';
 import { ITestConfigurationService, ITestsHelper } from './common/types';
@@ -20,7 +29,8 @@ import { DelayedTrigger, IDelayedTrigger } from '../common/utils/delayTrigger';
 import { ExtensionContextKey } from '../common/application/contextKeys';
 import { checkForFailedTests, updateTestResultMap } from './testController/common/testItemUtilities';
 import { Testing } from '../common/utils/localize';
-import { traceVerbose } from '../logging';
+import { traceVerbose, traceWarn } from '../logging';
+import { writeTestIdToClipboard } from './utils';
 
 @injectable()
 export class TestingService implements ITestingService {
@@ -32,6 +42,91 @@ export class TestingService implements ITestingService {
     }
 }
 
+/**
+ * Registers command handlers but defers service resolution until the commands are actually invoked,
+ * allowing registration to happen before all services are fully initialized.
+ */
+export function registerTestCommands(serviceContainer: IServiceContainer): void {
+    // Resolve only the essential services needed for command registration itself
+    const disposableRegistry = serviceContainer.get<Disposable[]>(IDisposableRegistry);
+    const commandManager = serviceContainer.get<ICommandManager>(ICommandManager);
+
+    // Helper function to configure tests - services are resolved when invoked, not at registration time
+    const configureTestsHandler = async (resource?: Uri) => {
+        sendTelemetryEvent(EventName.UNITTEST_CONFIGURE);
+
+        // Resolve services lazily when the command is invoked
+        const workspaceService = serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+
+        let wkspace: Uri | undefined;
+        if (resource) {
+            const wkspaceFolder = workspaceService.getWorkspaceFolder(resource);
+            wkspace = wkspaceFolder ? wkspaceFolder.uri : undefined;
+        } else {
+            const appShell = serviceContainer.get<IApplicationShell>(IApplicationShell);
+            wkspace = await selectTestWorkspace(appShell);
+        }
+        if (!wkspace) {
+            return;
+        }
+        const interpreterService = serviceContainer.get<IInterpreterService>(IInterpreterService);
+        const cmdManager = serviceContainer.get<ICommandManager>(ICommandManager);
+        if (!(await interpreterService.getActiveInterpreter(wkspace))) {
+            cmdManager.executeCommand(constants.Commands.TriggerEnvironmentSelection, wkspace);
+            return;
+        }
+        const configurationService = serviceContainer.get<ITestConfigurationService>(ITestConfigurationService);
+        await configurationService.promptToEnableAndConfigureTestFramework(wkspace);
+    };
+
+    disposableRegistry.push(
+        // Command: python.configureTests - prompts user to configure test framework
+        commandManager.registerCommand(
+            constants.Commands.Tests_Configure,
+            (_, _cmdSource: constants.CommandSource = constants.CommandSource.commandPalette, resource?: Uri) => {
+                // Invoke configuration handler (errors are ignored as this can be called from multiple places)
+                configureTestsHandler(resource).ignoreErrors();
+                traceVerbose('Testing: Trigger refresh after config change');
+                // Refresh test data if test controller is available (resolved lazily)
+                if (tests && !!tests.createTestController) {
+                    const testController = serviceContainer.get<ITestController>(ITestController);
+                    testController?.refreshTestData(resource, { forceRefresh: true });
+                }
+            },
+        ),
+        // Command: python.tests.copilotSetup - Copilot integration for test setup
+        commandManager.registerCommand(constants.Commands.Tests_CopilotSetup, (resource?: Uri):
+            | { message: string; command: Command }
+            | undefined => {
+            // Resolve services lazily when the command is invoked
+            const workspaceService = serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+            const wkspaceFolder =
+                workspaceService.getWorkspaceFolder(resource) || workspaceService.workspaceFolders?.at(0);
+            if (!wkspaceFolder) {
+                return undefined;
+            }
+
+            const configurationService = serviceContainer.get<ITestConfigurationService>(ITestConfigurationService);
+            if (configurationService.hasConfiguredTests(wkspaceFolder.uri)) {
+                return undefined;
+            }
+
+            return {
+                message: Testing.copilotSetupMessage,
+                command: {
+                    title: Testing.configureTests,
+                    command: constants.Commands.Tests_Configure,
+                    arguments: [undefined, constants.CommandSource.ui, resource],
+                },
+            };
+        }),
+        // Command: python.copyTestId - copies test ID to clipboard
+        commandManager.registerCommand(constants.Commands.CopyTestId, async (testItem: TestItem) => {
+            writeTestIdToClipboard(testItem);
+        }),
+    );
+}
+
 @injectable()
 export class UnitTestManagementService implements IExtensionActivationService {
     private activatedOnce: boolean = false;
@@ -70,7 +165,6 @@ export class UnitTestManagementService implements IExtensionActivationService {
         this.activatedOnce = true;
 
         this.registerHandlers();
-        this.registerCommands();
 
         if (!!tests.testResults) {
             await this.updateTestUIButtons();
@@ -93,22 +187,9 @@ export class UnitTestManagementService implements IExtensionActivationService {
                 if (unconfigured.length === workspaces.length) {
                     const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
                     await commandManager.executeCommand('workbench.view.testing.focus');
-
-                    // TODO: this is a workaround for https://github.com/microsoft/vscode/issues/130696
-                    // Once that is fixed delete this notification and test should be configured from the test view.
-                    const app = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
-                    const response = await app.showInformationMessage(
-                        Testing.testNotConfigured,
-                        Testing.configureTests,
+                    traceWarn(
+                        'Testing: Run attempted but no test configurations found for any workspace, use command palette to configure tests for python if desired.',
                     );
-                    if (response === Testing.configureTests) {
-                        await commandManager.executeCommand(
-                            constants.Commands.Tests_Configure,
-                            undefined,
-                            constants.CommandSource.ui,
-                            unconfigured[0].uri,
-                        );
-                    }
                 }
             });
         }
@@ -133,71 +214,6 @@ export class UnitTestManagementService implements IExtensionActivationService {
         await Promise.all(changedWorkspaces.map((u) => this.testController?.refreshTestData(u)));
     }
 
-    @captureTelemetry(EventName.UNITTEST_CONFIGURE, undefined, false)
-    private async configureTests(resource?: Uri) {
-        let wkspace: Uri | undefined;
-        if (resource) {
-            const wkspaceFolder = this.workspaceService.getWorkspaceFolder(resource);
-            wkspace = wkspaceFolder ? wkspaceFolder.uri : undefined;
-        } else {
-            const appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
-            wkspace = await selectTestWorkspace(appShell);
-        }
-        if (!wkspace) {
-            return;
-        }
-        const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
-        const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
-        if (!(await interpreterService.getActiveInterpreter(wkspace))) {
-            commandManager.executeCommand(constants.Commands.TriggerEnvironmentSelection, wkspace);
-            return;
-        }
-        const configurationService = this.serviceContainer.get<ITestConfigurationService>(ITestConfigurationService);
-        await configurationService.promptToEnableAndConfigureTestFramework(wkspace!);
-    }
-
-    private registerCommands(): void {
-        const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
-
-        this.disposableRegistry.push(
-            commandManager.registerCommand(
-                constants.Commands.Tests_Configure,
-                (_, _cmdSource: constants.CommandSource = constants.CommandSource.commandPalette, resource?: Uri) => {
-                    // Ignore the exceptions returned.
-                    // This command will be invoked from other places of the extension.
-                    this.configureTests(resource).ignoreErrors();
-                    traceVerbose('Testing: Trigger refresh after config change');
-                    this.testController?.refreshTestData(resource, { forceRefresh: true });
-                },
-            ),
-            commandManager.registerCommand(constants.Commands.Tests_CopilotSetup, (resource?: Uri):
-                | { message: string; command: Command }
-                | undefined => {
-                const wkspaceFolder =
-                    this.workspaceService.getWorkspaceFolder(resource) || this.workspaceService.workspaceFolders?.at(0);
-                if (!wkspaceFolder) {
-                    return undefined;
-                }
-
-                const configurationService = this.serviceContainer.get<ITestConfigurationService>(
-                    ITestConfigurationService,
-                );
-                if (configurationService.hasConfiguredTests(wkspaceFolder.uri)) {
-                    return undefined;
-                }
-
-                return {
-                    message: Testing.copilotSetupMessage,
-                    command: {
-                        title: Testing.configureTests,
-                        command: constants.Commands.Tests_Configure,
-                        arguments: [undefined, constants.CommandSource.ui, resource],
-                    },
-                };
-            }),
-        );
-    }
-
     private registerHandlers() {
         const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
         this.disposableRegistry.push(
diff --git a/src/client/testing/testController/common/argumentsHelper.ts b/src/client/testing/testController/common/argumentsHelper.ts
index ef2999551f02..c155d0197da7 100644
--- a/src/client/testing/testController/common/argumentsHelper.ts
+++ b/src/client/testing/testController/common/argumentsHelper.ts
@@ -3,22 +3,6 @@
 
 import { traceWarn } from '../../../logging';
 
-export function getOptionValues(args: string[], option: string): string[] {
-    const values: string[] = [];
-    let returnNextValue = false;
-    for (const arg of args) {
-        if (returnNextValue) {
-            values.push(arg);
-            returnNextValue = false;
-        } else if (arg.startsWith(`${option}=`)) {
-            values.push(arg.substring(`${option}=`.length));
-        } else if (arg === option) {
-            returnNextValue = true;
-        }
-    }
-    return values;
-}
-
 export function getPositionalArguments(
     args: string[],
     optionsWithArguments: string[] = [],
diff --git a/src/client/testing/testController/common/discoveryHelpers.ts b/src/client/testing/testController/common/discoveryHelpers.ts
new file mode 100644
index 000000000000..e170ad576ae8
--- /dev/null
+++ b/src/client/testing/testController/common/discoveryHelpers.ts
@@ -0,0 +1,137 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import { CancellationToken, CancellationTokenSource, Disposable, Uri } from 'vscode';
+import { Deferred } from '../../../common/utils/async';
+import { traceError, traceInfo, traceVerbose } from '../../../logging';
+import { createDiscoveryErrorPayload, fixLogLinesNoTrailing, startDiscoveryNamedPipe } from './utils';
+import { DiscoveredTestPayload, ITestResultResolver } from './types';
+
+/**
+ * Test provider type for logging purposes.
+ */
+export type TestProvider = 'pytest' | 'unittest';
+
+/**
+ * Sets up the discovery named pipe and wires up cancellation.
+ * @param resultResolver The resolver to handle discovered test data
+ * @param token Optional cancellation token from the caller
+ * @param uri Workspace URI for logging
+ * @returns Object containing the pipe name, cancellation source, and disposable for the external token handler
+ */
+export async function setupDiscoveryPipe(
+    resultResolver: ITestResultResolver | undefined,
+    token: CancellationToken | undefined,
+    uri: Uri,
+): Promise<{ pipeName: string; cancellation: CancellationTokenSource; tokenDisposable: Disposable | undefined }> {
+    const discoveryPipeCancellation = new CancellationTokenSource();
+
+    // Wire up cancellation from external token and store the disposable
+    const tokenDisposable = token?.onCancellationRequested(() => {
+        traceInfo(`Test discovery cancelled.`);
+        discoveryPipeCancellation.cancel();
+    });
+
+    // Start the named pipe with the discovery listener
+    const discoveryPipeName = await startDiscoveryNamedPipe((data: DiscoveredTestPayload) => {
+        if (!token?.isCancellationRequested) {
+            resultResolver?.resolveDiscovery(data);
+        }
+    }, discoveryPipeCancellation.token);
+
+    traceVerbose(`Created discovery pipe: ${discoveryPipeName} for workspace ${uri.fsPath}`);
+
+    return {
+        pipeName: discoveryPipeName,
+        cancellation: discoveryPipeCancellation,
+        tokenDisposable,
+    };
+}
+
+/**
+ * Creates standard process event handlers for test discovery subprocess.
+ * Handles stdout/stderr logging and error reporting on process exit.
+ *
+ * @param testProvider - The test framework being used ('pytest' or 'unittest')
+ * @param uri - The workspace URI
+ * @param cwd - The current working directory
+ * @param resultResolver - Resolver for test discovery results
+ * @param deferredTillExecClose - Deferred to resolve when process closes
+ * @param allowedSuccessCodes - Additional exit codes to treat as success (e.g., pytest exit code 5 for no tests found)
+ */
+export function createProcessHandlers(
+    testProvider: TestProvider,
+    uri: Uri,
+    cwd: string,
+    resultResolver: ITestResultResolver | undefined,
+    deferredTillExecClose: Deferred<void>,
+    allowedSuccessCodes: number[] = [],
+): {
+    onStdout: (data: any) => void;
+    onStderr: (data: any) => void;
+    onExit: (code: number | null, signal: NodeJS.Signals | null) => void;
+    onClose: (code: number | null, signal: NodeJS.Signals | null) => void;
+} {
+    const isSuccessCode = (code: number | null): boolean => {
+        return code === 0 || (code !== null && allowedSuccessCodes.includes(code));
+    };
+
+    return {
+        onStdout: (data: any) => {
+            const out = fixLogLinesNoTrailing(data.toString());
+            traceInfo(out);
+        },
+        onStderr: (data: any) => {
+            const out = fixLogLinesNoTrailing(data.toString());
+            traceError(out);
+        },
+        onExit: (code: number | null, _signal: NodeJS.Signals | null) => {
+            // The 'exit' event fires when the process terminates, but streams may still be open.
+            // Only log verbose success message here; error handling happens in onClose.
+            if (isSuccessCode(code)) {
+                traceVerbose(`${testProvider} discovery subprocess exited successfully for workspace ${uri.fsPath}`);
+            }
+        },
+        onClose: (code: number | null, signal: NodeJS.Signals | null) => {
+            // We resolve the deferred here to ensure all output has been captured.
+            if (!isSuccessCode(code)) {
+                traceError(
+                    `${testProvider} discovery failed with exit code ${code} and signal ${signal} for workspace ${uri.fsPath}. Creating error payload.`,
+                );
+                resultResolver?.resolveDiscovery(createDiscoveryErrorPayload(code, signal, cwd));
+            } else {
+                traceVerbose(`${testProvider} discovery subprocess streams closed for workspace ${uri.fsPath}`);
+            }
+            deferredTillExecClose?.resolve();
+        },
+    };
+}
+
+/**
+ * Handles cleanup when test discovery is cancelled.
+ * Kills the subprocess (if running), resolves the completion deferred, and cancels the discovery pipe.
+ *
+ * @param testProvider - The test framework being used ('pytest' or 'unittest')
+ * @param proc - The process to kill
+ * @param processCompletion - Deferred to resolve
+ * @param pipeCancellation - Cancellation token source to cancel
+ * @param uri - The workspace URI
+ */
+export function cleanupOnCancellation(
+    testProvider: TestProvider,
+    proc: { kill: () => void } | undefined,
+    processCompletion: Deferred<void>,
+    pipeCancellation: CancellationTokenSource,
+    uri: Uri,
+): void {
+    traceInfo(`Test discovery cancelled, killing ${testProvider} subprocess for workspace ${uri.fsPath}`);
+    if (proc) {
+        traceVerbose(`Killing ${testProvider} subprocess for workspace ${uri.fsPath}`);
+        proc.kill();
+    } else {
+        traceVerbose(`No ${testProvider} subprocess to kill for workspace ${uri.fsPath} (proc is undefined)`);
+    }
+    traceVerbose(`Resolving process completion deferred for ${testProvider} discovery in workspace ${uri.fsPath}`);
+    processCompletion.resolve();
+    traceVerbose(`Cancelling discovery pipe for ${testProvider} discovery in workspace ${uri.fsPath}`);
+    pipeCancellation.cancel();
+}
diff --git a/src/client/testing/testController/common/projectAdapter.ts b/src/client/testing/testController/common/projectAdapter.ts
new file mode 100644
index 000000000000..cfffbf439ca6
--- /dev/null
+++ b/src/client/testing/testController/common/projectAdapter.ts
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestItem, Uri } from 'vscode';
+import { TestProvider } from '../../types';
+import { ITestDiscoveryAdapter, ITestExecutionAdapter, ITestResultResolver } from './types';
+import { PythonEnvironment, PythonProject } from '../../../envExt/types';
+
+/**
+ * Represents a single Python project with its own test infrastructure.
+ * A project is defined as a combination of a Python executable + URI (folder/file).
+ * Projects are uniquely identified by their projectUri (use projectUri.toString() for map keys).
+ */
+export interface ProjectAdapter {
+    // === IDENTITY ===
+    /**
+     * Display name for the project (e.g., "alice (Python 3.11)").
+     */
+    projectName: string;
+
+    /**
+     * URI of the project root folder or file.
+     * This is the unique identifier for the project.
+     */
+    projectUri: Uri;
+
+    /**
+     * Parent workspace URI containing this project.
+     */
+    workspaceUri: Uri;
+
+    // === API OBJECTS (from vscode-python-environments extension) ===
+    /**
+     * The PythonProject object from the environment API.
+     */
+    pythonProject: PythonProject;
+
+    /**
+     * The resolved PythonEnvironment with execution details.
+     * Contains execInfo.run.executable for running tests.
+     */
+    pythonEnvironment: PythonEnvironment;
+
+    // === TEST INFRASTRUCTURE ===
+    /**
+     * Test framework provider ('pytest' | 'unittest').
+     */
+    testProvider: TestProvider;
+
+    /**
+     * Adapter for test discovery.
+     */
+    discoveryAdapter: ITestDiscoveryAdapter;
+
+    /**
+     * Adapter for test execution.
+     */
+    executionAdapter: ITestExecutionAdapter;
+
+    /**
+     * Result resolver for this project (maps test IDs and handles results).
+     */
+    resultResolver: ITestResultResolver;
+
+    /**
+     * Absolute paths of nested projects to ignore during discovery.
+     * Used to pass --ignore flags to pytest or exclusion filters to unittest.
+     * Only populated for parent projects that contain nested child projects.
+     */
+    nestedProjectPathsToIgnore?: string[];
+
+    // === LIFECYCLE ===
+    /**
+     * Whether discovery is currently running for this project.
+     */
+    isDiscovering: boolean;
+
+    /**
+     * Whether tests are currently executing for this project.
+     */
+    isExecuting: boolean;
+
+    /**
+     * Root TestItem for this project in the VS Code test tree.
+     * All project tests are children of this item.
+     */
+    projectRootTestItem?: TestItem;
+}
diff --git a/src/client/testing/testController/common/projectTestExecution.ts b/src/client/testing/testController/common/projectTestExecution.ts
new file mode 100644
index 000000000000..fe3b4f91491a
--- /dev/null
+++ b/src/client/testing/testController/common/projectTestExecution.ts
@@ -0,0 +1,296 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { CancellationToken, FileCoverageDetail, TestItem, TestRun, TestRunProfileKind, TestRunRequest } from 'vscode';
+import { traceError, traceInfo, traceVerbose, traceWarn } from '../../../logging';
+import { sendTelemetryEvent } from '../../../telemetry';
+import { EventName } from '../../../telemetry/constants';
+import { IPythonExecutionFactory } from '../../../common/process/types';
+import { ITestDebugLauncher } from '../../common/types';
+import { ProjectAdapter } from './projectAdapter';
+import { TestProjectRegistry } from './testProjectRegistry';
+import { getProjectId } from './projectUtils';
+import { getEnvExtApi, useEnvExtension } from '../../../envExt/api.internal';
+import { isParentPath } from '../../../pythonEnvironments/common/externalDependencies';
+
+/** Dependencies for project-based test execution. */
+export interface ProjectExecutionDependencies {
+    projectRegistry: TestProjectRegistry;
+    pythonExecFactory: IPythonExecutionFactory;
+    debugLauncher: ITestDebugLauncher;
+}
+
+/** Executes tests for multiple projects, grouping by project and using each project's Python environment. */
+export async function executeTestsForProjects(
+    projects: ProjectAdapter[],
+    testItems: TestItem[],
+    runInstance: TestRun,
+    request: TestRunRequest,
+    token: CancellationToken,
+    deps: ProjectExecutionDependencies,
+): Promise<void> {
+    if (projects.length === 0) {
+        traceError(`[test-by-project] No projects provided for execution`);
+        return;
+    }
+
+    // Early exit if already cancelled
+    if (token.isCancellationRequested) {
+        traceInfo(`[test-by-project] Execution cancelled before starting`);
+        return;
+    }
+
+    // Group test items by project
+    const testsByProject = await groupTestItemsByProject(testItems, projects);
+
+    const isDebugMode = request.profile?.kind === TestRunProfileKind.Debug;
+    traceInfo(`[test-by-project] Executing tests across ${testsByProject.size} project(s), debug=${isDebugMode}`);
+
+    // Setup coverage once for all projects (single callback that routes by file path)
+    if (request.profile?.kind === TestRunProfileKind.Coverage) {
+        setupCoverageForProjects(request, projects);
+    }
+
+    // Execute tests for each project in parallel
+    // For debug mode, multiple debug sessions will be launched in parallel
+    // Each execution respects cancellation via runInstance.token
+    const executions = Array.from(testsByProject.entries()).map(async ([_projectId, { project, items }]) => {
+        // Check for cancellation before starting each project
+        if (token.isCancellationRequested) {
+            traceInfo(`[test-by-project] Skipping ${project.projectName} - cancellation requested`);
+            return;
+        }
+
+        if (items.length === 0) return;
+
+        traceInfo(`[test-by-project] Executing ${items.length} test item(s) for project: ${project.projectName}`);
+
+        sendTelemetryEvent(EventName.UNITTEST_RUN, undefined, {
+            tool: project.testProvider,
+            debugging: isDebugMode,
+        });
+
+        try {
+            await executeTestsForProject(project, items, runInstance, request, deps);
+        } catch (error) {
+            // Don't log cancellation as an error
+            if (!token.isCancellationRequested) {
+                traceError(`[test-by-project] Execution failed for project ${project.projectName}:`, error);
+            }
+        }
+    });
+
+    await Promise.all(executions);
+
+    if (token.isCancellationRequested) {
+        traceInfo(`[test-by-project] Project executions cancelled`);
+    } else {
+        traceInfo(`[test-by-project] All project executions completed`);
+    }
+}
+
+/** Lookup context for caching project lookups within a single test run. */
+interface ProjectLookupContext {
+    uriToAdapter: Map<string, ProjectAdapter | undefined>;
+    projectPathToAdapter: Map<string, ProjectAdapter>;
+}
+
+/** Groups test items by owning project using env API or path-based matching as fallback. */
+export async function groupTestItemsByProject(
+    testItems: TestItem[],
+    projects: ProjectAdapter[],
+): Promise<Map<string, { project: ProjectAdapter; items: TestItem[] }>> {
+    const result = new Map<string, { project: ProjectAdapter; items: TestItem[] }>();
+
+    // Initialize entries for all projects
+    for (const project of projects) {
+        result.set(getProjectId(project.projectUri), { project, items: [] });
+    }
+
+    // Build lookup context for this run - O(p) one-time setup, enables O(1) lookups per item.
+    // When tests are from a single project, most lookups hit the cache after the first item.
+    const lookupContext: ProjectLookupContext = {
+        uriToAdapter: new Map(),
+        projectPathToAdapter: new Map(projects.map((p) => [p.projectUri.fsPath, p])),
+    };
+
+    // Assign each test item to its project
+    for (const item of testItems) {
+        const project = await findProjectForTestItem(item, projects, lookupContext);
+        if (project) {
+            const entry = result.get(getProjectId(project.projectUri));
+            if (entry) {
+                entry.items.push(item);
+            }
+        } else {
+            // If no project matches, log it
+            traceWarn(`[test-by-project] Could not match test item ${item.id} to a project`);
+        }
+    }
+
+    // Remove projects with no test items
+    for (const [projectId, entry] of result.entries()) {
+        if (entry.items.length === 0) {
+            result.delete(projectId);
+        }
+    }
+
+    return result;
+}
+
+/** Finds the project that owns a test item. */
+export async function findProjectForTestItem(
+    item: TestItem,
+    projects: ProjectAdapter[],
+    lookupContext?: ProjectLookupContext,
+): Promise<ProjectAdapter | undefined> {
+    if (!item.uri) return undefined;
+
+    const uriPath = item.uri.fsPath;
+
+    // Check lookup context first - O(1)
+    if (lookupContext?.uriToAdapter.has(uriPath)) {
+        return lookupContext.uriToAdapter.get(uriPath);
+    }
+
+    let result: ProjectAdapter | undefined;
+
+    // Try using the Python Environment extension API first.
+    // Legacy path: when useEnvExtension() is false, this block is skipped and we go
+    // directly to findProjectByPath() below (path-based matching).
+    if (useEnvExtension()) {
+        try {
+            const envExtApi = await getEnvExtApi();
+            const pythonProject = envExtApi.getPythonProject(item.uri);
+            if (pythonProject) {
+                // Use lookup context for O(1) adapter lookup instead of O(p) linear search
+                result = lookupContext?.projectPathToAdapter.get(pythonProject.uri.fsPath);
+                if (!result) {
+                    // Fallback to linear search if lookup context not available
+                    result = projects.find((p) => p.projectUri.fsPath === pythonProject.uri.fsPath);
+                }
+            }
+        } catch (error) {
+            traceVerbose(`[test-by-project] Failed to use env extension API, falling back to path matching: ${error}`);
+        }
+    }
+
+    // Fallback: path-based matching when env API unavailable or didn't find a match.
+    // O(p) time complexity where p = number of projects.
+    if (!result) {
+        result = findProjectByPath(item, projects);
+    }
+
+    // Store result for future lookups of same file within this run - O(1)
+    if (lookupContext) {
+        lookupContext.uriToAdapter.set(uriPath, result);
+    }
+
+    return result;
+}
+
+/** Fallback: finds project using path-based matching. */
+function findProjectByPath(item: TestItem, projects: ProjectAdapter[]): ProjectAdapter | undefined {
+    if (!item.uri) return undefined;
+
+    const itemPath = item.uri.fsPath;
+    let bestMatch: ProjectAdapter | undefined;
+    let bestMatchLength = 0;
+
+    for (const project of projects) {
+        const projectPath = project.projectUri.fsPath;
+        // Use isParentPath for safe path-boundary matching (handles separators and case normalization)
+        if (isParentPath(itemPath, projectPath) && projectPath.length > bestMatchLength) {
+            bestMatch = project;
+            bestMatchLength = projectPath.length;
+        }
+    }
+
+    return bestMatch;
+}
+
+/** Executes tests for a single project using the project's Python environment. */
+export async function executeTestsForProject(
+    project: ProjectAdapter,
+    testItems: TestItem[],
+    runInstance: TestRun,
+    request: TestRunRequest,
+    deps: ProjectExecutionDependencies,
+): Promise<void> {
+    const processedTestItemIds = new Set<string>();
+    const uniqueTestCaseIds = new Set<string>();
+
+    // Mark items as started and collect test IDs (deduplicated to handle overlapping selections)
+    for (const item of testItems) {
+        const testCaseNodes = getTestCaseNodesRecursive(item);
+        for (const node of testCaseNodes) {
+            if (processedTestItemIds.has(node.id)) {
+                continue;
+            }
+            processedTestItemIds.add(node.id);
+            runInstance.started(node);
+            const runId = project.resultResolver.vsIdToRunId.get(node.id);
+            if (runId) {
+                uniqueTestCaseIds.add(runId);
+            }
+        }
+    }
+
+    const testCaseIds = Array.from(uniqueTestCaseIds);
+
+    if (testCaseIds.length === 0) {
+        traceVerbose(`[test-by-project] No test IDs found for project ${project.projectName}`);
+        return;
+    }
+
+    traceInfo(`[test-by-project] Running ${testCaseIds.length} test(s) for project: ${project.projectName}`);
+
+    // Execute tests using the project's execution adapter
+    await project.executionAdapter.runTests(
+        project.projectUri,
+        testCaseIds,
+        request.profile?.kind,
+        runInstance,
+        deps.pythonExecFactory,
+        deps.debugLauncher,
+        undefined, // interpreter not needed, project has its own environment
+        project,
+    );
+}
+
+/** Recursively gets all leaf test case nodes from a test item tree. */
+export function getTestCaseNodesRecursive(item: TestItem): TestItem[] {
+    const results: TestItem[] = [];
+    if (item.children.size === 0) {
+        // This is a leaf node (test case)
+        results.push(item);
+    } else {
+        // Recursively get children
+        item.children.forEach((child) => {
+            results.push(...getTestCaseNodesRecursive(child));
+        });
+    }
+    return results;
+}
+
+/** Sets up detailed coverage loading that routes to the correct project by file path. */
+export function setupCoverageForProjects(request: TestRunRequest, projects: ProjectAdapter[]): void {
+    if (request.profile?.kind === TestRunProfileKind.Coverage) {
+        // Create a single callback that routes to the correct project's coverage map by file path
+        request.profile.loadDetailedCoverage = (
+            _testRun: TestRun,
+            fileCoverage,
+            _token,
+        ): Thenable<FileCoverageDetail[]> => {
+            const filePath = fileCoverage.uri.fsPath;
+            // Find the project that has coverage data for this file
+            for (const project of projects) {
+                const details = project.resultResolver.detailedCoverageMap.get(filePath);
+                if (details) {
+                    return Promise.resolve(details);
+                }
+            }
+            return Promise.resolve([]);
+        };
+    }
+}
diff --git a/src/client/testing/testController/common/projectUtils.ts b/src/client/testing/testController/common/projectUtils.ts
new file mode 100644
index 000000000000..b104b7f6842d
--- /dev/null
+++ b/src/client/testing/testController/common/projectUtils.ts
@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Uri } from 'vscode';
+import { IConfigurationService } from '../../../common/types';
+import { IEnvironmentVariablesProvider } from '../../../common/variables/types';
+import { UNITTEST_PROVIDER } from '../../common/constants';
+import { TestProvider } from '../../types';
+import { ITestDiscoveryAdapter, ITestExecutionAdapter, ITestResultResolver } from './types';
+import { UnittestTestDiscoveryAdapter } from '../unittest/testDiscoveryAdapter';
+import { UnittestTestExecutionAdapter } from '../unittest/testExecutionAdapter';
+import { PytestTestDiscoveryAdapter } from '../pytest/pytestDiscoveryAdapter';
+import { PytestTestExecutionAdapter } from '../pytest/pytestExecutionAdapter';
+
+/**
+ * Separator used to scope test IDs to a specific project.
+ * Format: {projectId}{SEPARATOR}{testPath}
+ * Example: "file:///workspace/project@@PROJECT@@test_file.py::test_name"
+ */
+export const PROJECT_ID_SEPARATOR = '@@vsc@@';
+
+/**
+ * Gets the project ID from a project URI.
+ * The project ID is simply the string representation of the URI, matching how
+ * the Python Environments extension stores projects in Map<string, PythonProject>.
+ *
+ * @param projectUri The project URI
+ * @returns The project ID (URI as string)
+ */
+export function getProjectId(projectUri: Uri): string {
+    return projectUri.toString();
+}
+
+/**
+ * Parses a project-scoped vsId back into its components.
+ *
+ * @param vsId The VS Code test item ID to parse
+ * @returns A tuple of [projectId, runId]. If the ID is not project-scoped,
+ *          returns [undefined, vsId] (legacy format)
+ */
+export function parseVsId(vsId: string): [string | undefined, string] {
+    const separatorIndex = vsId.indexOf(PROJECT_ID_SEPARATOR);
+    if (separatorIndex === -1) {
+        return [undefined, vsId]; // Legacy ID without project scope
+    }
+    return [vsId.substring(0, separatorIndex), vsId.substring(separatorIndex + PROJECT_ID_SEPARATOR.length)];
+}
+
+/**
+ * Creates a display name for a project including Python version.
+ * Format: "{projectName} (Python {version})"
+ *
+ * @param projectName The name of the project
+ * @param pythonVersion The Python version string (e.g., "3.11.2")
+ * @returns Formatted display name
+ */
+export function createProjectDisplayName(projectName: string, pythonVersion: string): string {
+    // Extract major.minor version if full version provided
+    const versionMatch = pythonVersion.match(/^(\d+\.\d+)/);
+    const shortVersion = versionMatch ? versionMatch[1] : pythonVersion;
+
+    return `${projectName} (Python ${shortVersion})`;
+}
+
+/**
+ * Creates test adapters (discovery and execution) for a given test provider.
+ *
+ * @param testProvider The test framework provider ('pytest' | 'unittest')
+ * @param resultResolver The result resolver to use for test results
+ * @param configSettings The configuration service
+ * @param envVarsService The environment variables provider
+ * @returns An object containing the discovery and execution adapters
+ */
+export function createTestAdapters(
+    testProvider: TestProvider,
+    resultResolver: ITestResultResolver,
+    configSettings: IConfigurationService,
+    envVarsService: IEnvironmentVariablesProvider,
+): { discoveryAdapter: ITestDiscoveryAdapter; executionAdapter: ITestExecutionAdapter } {
+    if (testProvider === UNITTEST_PROVIDER) {
+        return {
+            discoveryAdapter: new UnittestTestDiscoveryAdapter(configSettings, resultResolver, envVarsService),
+            executionAdapter: new UnittestTestExecutionAdapter(configSettings, resultResolver, envVarsService),
+        };
+    }
+
+    return {
+        discoveryAdapter: new PytestTestDiscoveryAdapter(configSettings, resultResolver, envVarsService),
+        executionAdapter: new PytestTestExecutionAdapter(configSettings, resultResolver, envVarsService),
+    };
+}
diff --git a/src/client/testing/testController/common/resultResolver.ts b/src/client/testing/testController/common/resultResolver.ts
index 80e57edbabd2..c126d233de1b 100644
--- a/src/client/testing/testController/common/resultResolver.ts
+++ b/src/client/testing/testController/common/resultResolver.ts
@@ -1,324 +1,137 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import {
-    CancellationToken,
-    TestController,
-    TestItem,
-    Uri,
-    TestMessage,
-    Location,
-    TestRun,
-    MarkdownString,
-    TestCoverageCount,
-    FileCoverage,
-    FileCoverageDetail,
-    StatementCoverage,
-    Range,
-} from 'vscode';
-import * as util from 'util';
+import { CancellationToken, TestController, TestItem, Uri, TestRun, FileCoverageDetail } from 'vscode';
 import { CoveragePayload, DiscoveredTestPayload, ExecutionTestPayload, ITestResultResolver } from './types';
 import { TestProvider } from '../../types';
-import { traceError, traceVerbose } from '../../../logging';
-import { Testing } from '../../../common/utils/localize';
-import { clearAllChildren, createErrorTestItem, getTestCaseNodes } from './testItemUtilities';
+import { traceInfo } from '../../../logging';
 import { sendTelemetryEvent } from '../../../telemetry';
 import { EventName } from '../../../telemetry/constants';
-import { splitLines } from '../../../common/stringUtils';
-import { buildErrorNodeOptions, populateTestTree, splitTestNameWithRegex } from './utils';
+import { TestItemIndex } from './testItemIndex';
+import { TestDiscoveryHandler } from './testDiscoveryHandler';
+import { TestExecutionHandler } from './testExecutionHandler';
+import { TestCoverageHandler } from './testCoverageHandler';
 
 export class PythonResultResolver implements ITestResultResolver {
     testController: TestController;
 
     testProvider: TestProvider;
 
-    public runIdToTestItem: Map<string, TestItem>;
+    private testItemIndex: TestItemIndex;
 
-    public runIdToVSid: Map<string, string>;
-
-    public vsIdToRunId: Map<string, string>;
-
-    public subTestStats: Map<string, { passed: number; failed: number }> = new Map();
+    // Shared singleton handlers
+    private static discoveryHandler: TestDiscoveryHandler = new TestDiscoveryHandler();
+    private static executionHandler: TestExecutionHandler = new TestExecutionHandler();
+    private static coverageHandler: TestCoverageHandler = new TestCoverageHandler();
 
     public detailedCoverageMap = new Map<string, FileCoverageDetail[]>();
 
-    constructor(testController: TestController, testProvider: TestProvider, private workspaceUri: Uri) {
+    /**
+     * Optional project ID for scoping test IDs.
+     * When set, all test IDs are prefixed with `{projectId}@@vsc@@` for project-based testing.
+     * When undefined, uses legacy workspace-level IDs for backward compatibility.
+     */
+    private projectId?: string;
+
+    /**
+     * Optional project display name for labeling the test tree root.
+     * When set, the root node label will be "project: {projectName}" instead of the folder name.
+     */
+    private projectName?: string;
+
+    constructor(
+        testController: TestController,
+        testProvider: TestProvider,
+        private workspaceUri: Uri,
+        projectId?: string,
+        projectName?: string,
+    ) {
         this.testController = testController;
         this.testProvider = testProvider;
-
-        this.runIdToTestItem = new Map<string, TestItem>();
-        this.runIdToVSid = new Map<string, string>();
-        this.vsIdToRunId = new Map<string, string>();
+        this.projectId = projectId;
+        this.projectName = projectName;
+        // Initialize a new TestItemIndex which will be used to track test items in this workspace/project
+        this.testItemIndex = new TestItemIndex();
     }
 
-    public resolveDiscovery(payload: DiscoveredTestPayload, token?: CancellationToken): void {
-        if (!payload) {
-            // No test data is available
-        } else {
-            this._resolveDiscovery(payload as DiscoveredTestPayload, token);
-        }
+    // Expose for backward compatibility (WorkspaceTestAdapter accesses these)
+    public get runIdToTestItem(): Map<string, TestItem> {
+        return this.testItemIndex.runIdToTestItemMap;
     }
 
-    public _resolveDiscovery(payload: DiscoveredTestPayload, token?: CancellationToken): void {
-        const workspacePath = this.workspaceUri.fsPath;
-        const rawTestData = payload as DiscoveredTestPayload;
-        // Check if there were any errors in the discovery process.
-        if (rawTestData.status === 'error') {
-            const testingErrorConst =
-                this.testProvider === 'pytest' ? Testing.errorPytestDiscovery : Testing.errorUnittestDiscovery;
-            const { error } = rawTestData;
-            traceError(testingErrorConst, 'for workspace: ', workspacePath, '\r\n', error?.join('\r\n\r\n') ?? '');
-
-            let errorNode = this.testController.items.get(`DiscoveryError:${workspacePath}`);
-            const message = util.format(
-                `${testingErrorConst} ${Testing.seePythonOutput}\r\n`,
-                error?.join('\r\n\r\n') ?? '',
-            );
+    public get runIdToVSid(): Map<string, string> {
+        return this.testItemIndex.runIdToVSidMap;
+    }
 
-            if (errorNode === undefined) {
-                const options = buildErrorNodeOptions(this.workspaceUri, message, this.testProvider);
-                errorNode = createErrorTestItem(this.testController, options);
-                this.testController.items.add(errorNode);
-            }
-            const errorNodeLabel: MarkdownString = new MarkdownString(
-                `[Show output](command:python.viewOutput) to view error logs`,
-            );
-            errorNodeLabel.isTrusted = true;
-            errorNode.error = errorNodeLabel;
-        } else {
-            // remove error node only if no errors exist.
-            this.testController.items.delete(`DiscoveryError:${workspacePath}`);
-        }
-        if (rawTestData.tests || rawTestData.tests === null) {
-            // if any tests exist, they should be populated in the test tree, regardless of whether there were errors or not.
-            // parse and insert test data.
+    public get vsIdToRunId(): Map<string, string> {
+        return this.testItemIndex.vsIdToRunIdMap;
+    }
 
-            // If the test root for this folder exists: Workspace refresh, update its children.
-            // Otherwise, it is a freshly discovered workspace, and we need to create a new test root and populate the test tree.
-            populateTestTree(this.testController, rawTestData.tests, undefined, this, token);
-        }
+    /**
+     * Gets the project ID for this resolver (if any).
+     * Used for project-scoped test ID generation.
+     */
+    public getProjectId(): string | undefined {
+        return this.projectId;
+    }
 
+    public resolveDiscovery(payload: DiscoveredTestPayload, token?: CancellationToken): void {
+        PythonResultResolver.discoveryHandler.processDiscovery(
+            payload,
+            this.testController,
+            this.testItemIndex,
+            this.workspaceUri,
+            this.testProvider,
+            token,
+            this.projectId,
+            this.projectName,
+        );
         sendTelemetryEvent(EventName.UNITTEST_DISCOVERY_DONE, undefined, {
             tool: this.testProvider,
             failed: false,
         });
     }
 
+    public _resolveDiscovery(payload: DiscoveredTestPayload, token?: CancellationToken): void {
+        // Delegate to the public method for backward compatibility
+        this.resolveDiscovery(payload, token);
+    }
+
     public resolveExecution(payload: ExecutionTestPayload | CoveragePayload, runInstance: TestRun): void {
         if ('coverage' in payload) {
             // coverage data is sent once per connection
-            traceVerbose('Coverage data received.');
-            this._resolveCoverage(payload as CoveragePayload, runInstance);
+            traceInfo('Coverage data received, processing...');
+            this.detailedCoverageMap = PythonResultResolver.coverageHandler.processCoverage(
+                payload as CoveragePayload,
+                runInstance,
+            );
+            traceInfo('Coverage data processing complete.');
         } else {
-            this._resolveExecution(payload as ExecutionTestPayload, runInstance);
-        }
-    }
-
-    public _resolveCoverage(payload: CoveragePayload, runInstance: TestRun): void {
-        if (payload.result === undefined) {
-            return;
-        }
-        for (const [key, value] of Object.entries(payload.result)) {
-            const fileNameStr = key;
-            const fileCoverageMetrics = value;
-            const linesCovered = fileCoverageMetrics.lines_covered ? fileCoverageMetrics.lines_covered : []; // undefined if no lines covered
-            const linesMissed = fileCoverageMetrics.lines_missed ? fileCoverageMetrics.lines_missed : []; // undefined if no lines missed
-
-            const lineCoverageCount = new TestCoverageCount(
-                linesCovered.length,
-                linesCovered.length + linesMissed.length,
+            PythonResultResolver.executionHandler.processExecution(
+                payload as ExecutionTestPayload,
+                runInstance,
+                this.testItemIndex,
+                this.testController,
             );
-            const uri = Uri.file(fileNameStr);
-            const fileCoverage = new FileCoverage(uri, lineCoverageCount);
-            runInstance.addCoverage(fileCoverage);
-
-            // create detailed coverage array for each file (only line coverage on detailed, not branch)
-            const detailedCoverageArray: FileCoverageDetail[] = [];
-            // go through all covered lines, create new StatementCoverage, and add to detailedCoverageArray
-            for (const line of linesCovered) {
-                // line is 1-indexed, so we need to subtract 1 to get the 0-indexed line number
-                // true value means line is covered
-                const statementCoverage = new StatementCoverage(
-                    true,
-                    new Range(line - 1, 0, line - 1, Number.MAX_SAFE_INTEGER),
-                );
-                detailedCoverageArray.push(statementCoverage);
-            }
-            for (const line of linesMissed) {
-                // line is 1-indexed, so we need to subtract 1 to get the 0-indexed line number
-                // false value means line is NOT covered
-                const statementCoverage = new StatementCoverage(
-                    false,
-                    new Range(line - 1, 0, line - 1, Number.MAX_SAFE_INTEGER),
-                );
-                detailedCoverageArray.push(statementCoverage);
-            }
-
-            this.detailedCoverageMap.set(uri.fsPath, detailedCoverageArray);
         }
     }
 
     public _resolveExecution(payload: ExecutionTestPayload, runInstance: TestRun): void {
-        const rawTestExecData = payload as ExecutionTestPayload;
-        if (rawTestExecData !== undefined && rawTestExecData.result !== undefined) {
-            // Map which holds the subtest information for each test item.
-
-            // iterate through payload and update the UI accordingly.
-            for (const keyTemp of Object.keys(rawTestExecData.result)) {
-                const testCases: TestItem[] = [];
-
-                // grab leaf level test items
-                this.testController.items.forEach((i) => {
-                    const tempArr: TestItem[] = getTestCaseNodes(i);
-                    testCases.push(...tempArr);
-                });
-                const testItem = rawTestExecData.result[keyTemp];
-
-                if (testItem.outcome === 'error') {
-                    const rawTraceback = testItem.traceback ?? '';
-                    const traceback = splitLines(rawTraceback, {
-                        trim: false,
-                        removeEmptyEntries: true,
-                    }).join('\r\n');
-                    const text = `${testItem.test} failed with error: ${
-                        testItem.message ?? testItem.outcome
-                    }\r\n${traceback}`;
-                    const message = new TestMessage(text);
-
-                    const grabVSid = this.runIdToVSid.get(keyTemp);
-                    // search through freshly built array of testItem to find the failed test and update UI.
-                    testCases.forEach((indiItem) => {
-                        if (indiItem.id === grabVSid) {
-                            if (indiItem.uri) {
-                                if (indiItem.range) {
-                                    message.location = new Location(indiItem.uri, indiItem.range);
-                                }
-                                runInstance.errored(indiItem, message);
-                            }
-                        }
-                    });
-                } else if (testItem.outcome === 'failure' || testItem.outcome === 'passed-unexpected') {
-                    const rawTraceback = testItem.traceback ?? '';
-                    const traceback = splitLines(rawTraceback, {
-                        trim: false,
-                        removeEmptyEntries: true,
-                    }).join('\r\n');
-
-                    const text = `${testItem.test} failed: ${testItem.message ?? testItem.outcome}\r\n${traceback}`;
-                    const message = new TestMessage(text);
+        // Delegate to the public method for backward compatibility
+        this.resolveExecution(payload, runInstance);
+    }
 
-                    // note that keyTemp is a runId for unittest library...
-                    const grabVSid = this.runIdToVSid.get(keyTemp);
-                    // search through freshly built array of testItem to find the failed test and update UI.
-                    testCases.forEach((indiItem) => {
-                        if (indiItem.id === grabVSid) {
-                            if (indiItem.uri) {
-                                if (indiItem.range) {
-                                    message.location = new Location(indiItem.uri, indiItem.range);
-                                }
-                                runInstance.failed(indiItem, message);
-                            }
-                        }
-                    });
-                } else if (testItem.outcome === 'success' || testItem.outcome === 'expected-failure') {
-                    const grabTestItem = this.runIdToTestItem.get(keyTemp);
-                    const grabVSid = this.runIdToVSid.get(keyTemp);
-                    if (grabTestItem !== undefined) {
-                        testCases.forEach((indiItem) => {
-                            if (indiItem.id === grabVSid) {
-                                if (indiItem.uri) {
-                                    runInstance.passed(grabTestItem);
-                                }
-                            }
-                        });
-                    }
-                } else if (testItem.outcome === 'skipped') {
-                    const grabTestItem = this.runIdToTestItem.get(keyTemp);
-                    const grabVSid = this.runIdToVSid.get(keyTemp);
-                    if (grabTestItem !== undefined) {
-                        testCases.forEach((indiItem) => {
-                            if (indiItem.id === grabVSid) {
-                                if (indiItem.uri) {
-                                    runInstance.skipped(grabTestItem);
-                                }
-                            }
-                        });
-                    }
-                } else if (testItem.outcome === 'subtest-failure') {
-                    // split on [] or () based on how the subtest is setup.
-                    const [parentTestCaseId, subtestId] = splitTestNameWithRegex(keyTemp);
-                    const parentTestItem = this.runIdToTestItem.get(parentTestCaseId);
-                    const data = testItem;
-                    // find the subtest's parent test item
-                    if (parentTestItem) {
-                        const subtestStats = this.subTestStats.get(parentTestCaseId);
-                        if (subtestStats) {
-                            subtestStats.failed += 1;
-                        } else {
-                            this.subTestStats.set(parentTestCaseId, {
-                                failed: 1,
-                                passed: 0,
-                            });
-                            // clear since subtest items don't persist between runs
-                            clearAllChildren(parentTestItem);
-                        }
-                        const subTestItem = this.testController?.createTestItem(
-                            subtestId,
-                            subtestId,
-                            parentTestItem.uri,
-                        );
-                        // create a new test item for the subtest
-                        if (subTestItem) {
-                            const traceback = data.traceback ?? '';
-                            const text = `${data.subtest} failed: ${
-                                testItem.message ?? testItem.outcome
-                            }\r\n${traceback}`;
-                            parentTestItem.children.add(subTestItem);
-                            runInstance.started(subTestItem);
-                            const message = new TestMessage(text);
-                            if (parentTestItem.uri && parentTestItem.range) {
-                                message.location = new Location(parentTestItem.uri, parentTestItem.range);
-                            }
-                            runInstance.failed(subTestItem, message);
-                        } else {
-                            throw new Error('Unable to create new child node for subtest');
-                        }
-                    } else {
-                        throw new Error('Parent test item not found');
-                    }
-                } else if (testItem.outcome === 'subtest-success') {
-                    // split on [] or () based on how the subtest is setup.
-                    const [parentTestCaseId, subtestId] = splitTestNameWithRegex(keyTemp);
-                    const parentTestItem = this.runIdToTestItem.get(parentTestCaseId);
+    public _resolveCoverage(payload: CoveragePayload, runInstance: TestRun): void {
+        // Delegate to the public method for backward compatibility
+        this.resolveExecution(payload, runInstance);
+    }
 
-                    // find the subtest's parent test item
-                    if (parentTestItem) {
-                        const subtestStats = this.subTestStats.get(parentTestCaseId);
-                        if (subtestStats) {
-                            subtestStats.passed += 1;
-                        } else {
-                            this.subTestStats.set(parentTestCaseId, { failed: 0, passed: 1 });
-                            // clear since subtest items don't persist between runs
-                            clearAllChildren(parentTestItem);
-                        }
-                        const subTestItem = this.testController?.createTestItem(
-                            subtestId,
-                            subtestId,
-                            parentTestItem.uri,
-                        );
-                        // create a new test item for the subtest
-                        if (subTestItem) {
-                            parentTestItem.children.add(subTestItem);
-                            runInstance.started(subTestItem);
-                            runInstance.passed(subTestItem);
-                        } else {
-                            throw new Error('Unable to create new child node for subtest');
-                        }
-                    } else {
-                        throw new Error('Parent test item not found');
-                    }
-                }
-            }
-        }
+    /**
+     * Clean up stale test item references from the cache maps.
+     * Validates cached items and removes any that are no longer in the test tree.
+     * Delegates to TestItemIndex.
+     */
+    public cleanupStaleReferences(): void {
+        this.testItemIndex.cleanupStaleReferences(this.testController);
     }
 }
diff --git a/src/client/testing/testController/common/testCoverageHandler.ts b/src/client/testing/testController/common/testCoverageHandler.ts
new file mode 100644
index 000000000000..81ec80579730
--- /dev/null
+++ b/src/client/testing/testController/common/testCoverageHandler.ts
@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestRun, Uri, TestCoverageCount, FileCoverage, FileCoverageDetail, StatementCoverage, Range } from 'vscode';
+import { CoveragePayload, FileCoverageMetrics } from './types';
+
+/**
+ * Stateless handler for processing coverage payloads and creating coverage objects.
+ * This handler is shared across all workspaces and contains no instance state.
+ */
+export class TestCoverageHandler {
+    /**
+     * Process coverage payload
+     * Pure function - returns coverage data without storing it
+     */
+    public processCoverage(payload: CoveragePayload, runInstance: TestRun): Map<string, FileCoverageDetail[]> {
+        const detailedCoverageMap = new Map<string, FileCoverageDetail[]>();
+
+        if (payload.result === undefined) {
+            return detailedCoverageMap;
+        }
+
+        for (const [key, value] of Object.entries(payload.result)) {
+            const fileNameStr = key;
+            const fileCoverageMetrics: FileCoverageMetrics = value;
+
+            // Create FileCoverage object and add to run instance
+            const fileCoverage = this.createFileCoverage(Uri.file(fileNameStr), fileCoverageMetrics);
+            runInstance.addCoverage(fileCoverage);
+
+            // Create detailed coverage array for this file
+            const detailedCoverage = this.createDetailedCoverage(
+                fileCoverageMetrics.lines_covered ?? [],
+                fileCoverageMetrics.lines_missed ?? [],
+            );
+            detailedCoverageMap.set(Uri.file(fileNameStr).fsPath, detailedCoverage);
+        }
+
+        return detailedCoverageMap;
+    }
+
+    /**
+     * Create FileCoverage object from metrics
+     */
+    private createFileCoverage(uri: Uri, metrics: FileCoverageMetrics): FileCoverage {
+        const linesCovered = metrics.lines_covered ?? [];
+        const linesMissed = metrics.lines_missed ?? [];
+        const executedBranches = metrics.executed_branches;
+        const totalBranches = metrics.total_branches;
+
+        const lineCoverageCount = new TestCoverageCount(linesCovered.length, linesCovered.length + linesMissed.length);
+
+        if (totalBranches === -1) {
+            // branch coverage was not enabled and should not be displayed
+            return new FileCoverage(uri, lineCoverageCount);
+        } else {
+            const branchCoverageCount = new TestCoverageCount(executedBranches, totalBranches);
+            return new FileCoverage(uri, lineCoverageCount, branchCoverageCount);
+        }
+    }
+
+    /**
+     * Create detailed coverage array for a file
+     * Only line coverage on detailed, not branch coverage
+     */
+    private createDetailedCoverage(linesCovered: number[], linesMissed: number[]): FileCoverageDetail[] {
+        const detailedCoverageArray: FileCoverageDetail[] = [];
+
+        // Add covered lines
+        for (const line of linesCovered) {
+            // line is 1-indexed, so we need to subtract 1 to get the 0-indexed line number
+            // true value means line is covered
+            const statementCoverage = new StatementCoverage(
+                true,
+                new Range(line - 1, 0, line - 1, Number.MAX_SAFE_INTEGER),
+            );
+            detailedCoverageArray.push(statementCoverage);
+        }
+
+        // Add missed lines
+        for (const line of linesMissed) {
+            // line is 1-indexed, so we need to subtract 1 to get the 0-indexed line number
+            // false value means line is NOT covered
+            const statementCoverage = new StatementCoverage(
+                false,
+                new Range(line - 1, 0, line - 1, Number.MAX_SAFE_INTEGER),
+            );
+            detailedCoverageArray.push(statementCoverage);
+        }
+
+        return detailedCoverageArray;
+    }
+}
diff --git a/src/client/testing/testController/common/testDiscoveryHandler.ts b/src/client/testing/testController/common/testDiscoveryHandler.ts
new file mode 100644
index 000000000000..3f70e6b68594
--- /dev/null
+++ b/src/client/testing/testController/common/testDiscoveryHandler.ts
@@ -0,0 +1,141 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { CancellationToken, TestController, Uri, MarkdownString } from 'vscode';
+import * as util from 'util';
+import { DiscoveredTestPayload } from './types';
+import { TestProvider } from '../../types';
+import { traceError, traceWarn } from '../../../logging';
+import { Testing } from '../../../common/utils/localize';
+import { createErrorTestItem } from './testItemUtilities';
+import { buildErrorNodeOptions, populateTestTree } from './utils';
+import { TestItemIndex } from './testItemIndex';
+import { PROJECT_ID_SEPARATOR } from './projectUtils';
+
+/**
+ * Stateless handler for processing discovery payloads and building/updating the TestItem tree.
+ * This handler is shared across all workspaces and contains no instance state.
+ */
+export class TestDiscoveryHandler {
+    /**
+     * Process discovery payload and update test tree
+     * Pure function - no instance state used
+     */
+    public processDiscovery(
+        payload: DiscoveredTestPayload,
+        testController: TestController,
+        testItemIndex: TestItemIndex,
+        workspaceUri: Uri,
+        testProvider: TestProvider,
+        token?: CancellationToken,
+        projectId?: string,
+        projectName?: string,
+    ): void {
+        if (!payload) {
+            // No test data is available
+            return;
+        }
+
+        const workspacePath = workspaceUri.fsPath;
+        const rawTestData = payload as DiscoveredTestPayload;
+
+        // Check if there were any errors in the discovery process.
+        if (rawTestData.status === 'error') {
+            this.createErrorNode(testController, workspaceUri, rawTestData.error, testProvider, projectId, projectName);
+        } else {
+            // remove error node only if no errors exist.
+            const errorNodeId = projectId
+                ? `${projectId}${PROJECT_ID_SEPARATOR}DiscoveryError:${workspacePath}`
+                : `DiscoveryError:${workspacePath}`;
+            testController.items.delete(errorNodeId);
+        }
+
+        if (rawTestData.tests || rawTestData.tests === null) {
+            // if any tests exist, they should be populated in the test tree, regardless of whether there were errors or not.
+            // parse and insert test data.
+
+            // Clear existing mappings before rebuilding test tree
+            testItemIndex.clear();
+
+            // If the test root for this folder exists: Workspace refresh, update its children.
+            // Otherwise, it is a freshly discovered workspace, and we need to create a new test root and populate the test tree.
+            // Note: populateTestTree will call testItemIndex.registerTestItem() for each discovered test
+            populateTestTree(
+                testController,
+                rawTestData.tests,
+                undefined,
+                {
+                    runIdToTestItem: testItemIndex.runIdToTestItemMap,
+                    runIdToVSid: testItemIndex.runIdToVSidMap,
+                    vsIdToRunId: testItemIndex.vsIdToRunIdMap,
+                },
+                token,
+                projectId,
+                projectName,
+            );
+        }
+    }
+
+    /**
+     * Create an error node for discovery failures
+     */
+    public createErrorNode(
+        testController: TestController,
+        workspaceUri: Uri,
+        error: string[] | undefined,
+        testProvider: TestProvider,
+        projectId?: string,
+        projectName?: string,
+    ): void {
+        const workspacePath = workspaceUri.fsPath;
+        const testingErrorConst =
+            testProvider === 'pytest' ? Testing.errorPytestDiscovery : Testing.errorUnittestDiscovery;
+
+        traceError(testingErrorConst, 'for workspace: ', workspacePath, '\r\n', error?.join('\r\n\r\n') ?? '');
+
+        // For unittest in project-based mode, check if the error might be caused by nested project imports
+        // This helps users understand that import errors from nested projects can be safely ignored
+        // if those tests are covered by a different project with the correct environment.
+        if (testProvider === 'unittest' && projectId) {
+            const errorText = error?.join(' ') ?? '';
+            const isImportError =
+                errorText.includes('ModuleNotFoundError') ||
+                errorText.includes('ImportError') ||
+                errorText.includes('No module named');
+
+            if (isImportError) {
+                const warningMessage =
+                    '--- ' +
+                    `[test-by-project] Import error during unittest discovery for project at ${workspacePath}. ` +
+                    'This may be caused by test files in nested project directories that require different dependencies. ' +
+                    'If these tests are discovered successfully by their own project (with the correct Python environment), ' +
+                    'this error can be safely ignored. To avoid this, consider excluding nested project paths from parent project discovery. ' +
+                    '---';
+                traceWarn(warningMessage);
+            }
+        }
+
+        const errorNodeId = projectId
+            ? `${projectId}${PROJECT_ID_SEPARATOR}DiscoveryError:${workspacePath}`
+            : `DiscoveryError:${workspacePath}`;
+        let errorNode = testController.items.get(errorNodeId);
+        const message = util.format(
+            `${testingErrorConst} ${Testing.seePythonOutput}\r\n`,
+            error?.join('\r\n\r\n') ?? '',
+        );
+
+        if (errorNode === undefined) {
+            const options = buildErrorNodeOptions(workspaceUri, message, testProvider, projectName);
+            // Update the error node ID to include project scope if applicable
+            options.id = errorNodeId;
+            errorNode = createErrorTestItem(testController, options);
+            testController.items.add(errorNode);
+        }
+
+        const errorNodeLabel: MarkdownString = new MarkdownString(
+            `[Show output](command:python.viewOutput) to view error logs`,
+        );
+        errorNodeLabel.isTrusted = true;
+        errorNode.error = errorNodeLabel;
+    }
+}
diff --git a/src/client/testing/testController/common/testExecutionHandler.ts b/src/client/testing/testController/common/testExecutionHandler.ts
new file mode 100644
index 000000000000..127e6980ae46
--- /dev/null
+++ b/src/client/testing/testController/common/testExecutionHandler.ts
@@ -0,0 +1,231 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestController, TestRun, TestMessage, Location } from 'vscode';
+import { ExecutionTestPayload } from './types';
+import { TestItemIndex } from './testItemIndex';
+import { splitLines } from '../../../common/stringUtils';
+import { splitTestNameWithRegex } from './utils';
+import { clearAllChildren } from './testItemUtilities';
+
+/**
+ * Stateless handler for processing execution payloads and updating TestRun instances.
+ * This handler is shared across all workspaces and contains no instance state.
+ */
+export class TestExecutionHandler {
+    /**
+     * Process execution payload and update test run
+     * Pure function - no instance state used
+     */
+    public processExecution(
+        payload: ExecutionTestPayload,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const rawTestExecData = payload as ExecutionTestPayload;
+
+        if (rawTestExecData !== undefined && rawTestExecData.result !== undefined) {
+            for (const keyTemp of Object.keys(rawTestExecData.result)) {
+                const testItem = rawTestExecData.result[keyTemp];
+
+                // Delegate to specific outcome handlers
+                this.handleTestOutcome(keyTemp, testItem, runInstance, testItemIndex, testController);
+            }
+        }
+    }
+
+    /**
+     * Handle a single test result based on outcome
+     */
+    private handleTestOutcome(
+        runId: string,
+        testItem: any,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        if (testItem.outcome === 'error') {
+            this.handleTestError(runId, testItem, runInstance, testItemIndex, testController);
+        } else if (testItem.outcome === 'failure' || testItem.outcome === 'passed-unexpected') {
+            this.handleTestFailure(runId, testItem, runInstance, testItemIndex, testController);
+        } else if (testItem.outcome === 'success' || testItem.outcome === 'expected-failure') {
+            this.handleTestSuccess(runId, runInstance, testItemIndex, testController);
+        } else if (testItem.outcome === 'skipped') {
+            this.handleTestSkipped(runId, runInstance, testItemIndex, testController);
+        } else if (testItem.outcome === 'subtest-failure') {
+            this.handleSubtestFailure(runId, testItem, runInstance, testItemIndex, testController);
+        } else if (testItem.outcome === 'subtest-success') {
+            this.handleSubtestSuccess(runId, runInstance, testItemIndex, testController);
+        }
+    }
+
+    /**
+     * Handle test items that errored during execution
+     */
+    private handleTestError(
+        runId: string,
+        testItem: any,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const rawTraceback = testItem.traceback ?? '';
+        const traceback = splitLines(rawTraceback, {
+            trim: false,
+            removeEmptyEntries: true,
+        }).join('\r\n');
+        const text = `${testItem.test} failed with error: ${testItem.message ?? testItem.outcome}\r\n${traceback}`;
+        const message = new TestMessage(text);
+
+        const foundItem = testItemIndex.getTestItem(runId, testController);
+
+        if (foundItem?.uri) {
+            if (foundItem.range) {
+                message.location = new Location(foundItem.uri, foundItem.range);
+            }
+            runInstance.errored(foundItem, message);
+        }
+    }
+
+    /**
+     * Handle test items that failed during execution
+     */
+    private handleTestFailure(
+        runId: string,
+        testItem: any,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const rawTraceback = testItem.traceback ?? '';
+        const traceback = splitLines(rawTraceback, {
+            trim: false,
+            removeEmptyEntries: true,
+        }).join('\r\n');
+
+        const text = `${testItem.test} failed: ${testItem.message ?? testItem.outcome}\r\n${traceback}`;
+        const message = new TestMessage(text);
+
+        const foundItem = testItemIndex.getTestItem(runId, testController);
+
+        if (foundItem?.uri) {
+            if (foundItem.range) {
+                message.location = new Location(foundItem.uri, foundItem.range);
+            }
+            runInstance.failed(foundItem, message);
+        }
+    }
+
+    /**
+     * Handle test items that passed during execution
+     */
+    private handleTestSuccess(
+        runId: string,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const foundItem = testItemIndex.getTestItem(runId, testController);
+
+        if (foundItem !== undefined && foundItem.uri) {
+            runInstance.passed(foundItem);
+        }
+    }
+
+    /**
+     * Handle test items that were skipped during execution
+     */
+    private handleTestSkipped(
+        runId: string,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const foundItem = testItemIndex.getTestItem(runId, testController);
+
+        if (foundItem !== undefined && foundItem.uri) {
+            runInstance.skipped(foundItem);
+        }
+    }
+
+    /**
+     * Handle subtest failures
+     */
+    private handleSubtestFailure(
+        runId: string,
+        testItem: any,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const [parentTestCaseId, subtestId] = splitTestNameWithRegex(runId);
+        const parentTestItem = testItemIndex.getTestItem(parentTestCaseId, testController);
+
+        if (parentTestItem) {
+            const stats = testItemIndex.getSubtestStats(parentTestCaseId);
+            if (stats) {
+                stats.failed += 1;
+            } else {
+                testItemIndex.setSubtestStats(parentTestCaseId, {
+                    failed: 1,
+                    passed: 0,
+                });
+                clearAllChildren(parentTestItem);
+            }
+
+            const subTestItem = testController?.createTestItem(subtestId, subtestId, parentTestItem.uri);
+
+            if (subTestItem) {
+                const traceback = testItem.traceback ?? '';
+                const text = `${testItem.subtest} failed: ${testItem.message ?? testItem.outcome}\r\n${traceback}`;
+                parentTestItem.children.add(subTestItem);
+                runInstance.started(subTestItem);
+                const message = new TestMessage(text);
+                if (parentTestItem.uri && parentTestItem.range) {
+                    message.location = new Location(parentTestItem.uri, parentTestItem.range);
+                }
+                runInstance.failed(subTestItem, message);
+            } else {
+                throw new Error('Unable to create new child node for subtest');
+            }
+        } else {
+            throw new Error('Parent test item not found');
+        }
+    }
+
+    /**
+     * Handle subtest successes
+     */
+    private handleSubtestSuccess(
+        runId: string,
+        runInstance: TestRun,
+        testItemIndex: TestItemIndex,
+        testController: TestController,
+    ): void {
+        const [parentTestCaseId, subtestId] = splitTestNameWithRegex(runId);
+        const parentTestItem = testItemIndex.getTestItem(parentTestCaseId, testController);
+
+        if (parentTestItem) {
+            const stats = testItemIndex.getSubtestStats(parentTestCaseId);
+            if (stats) {
+                stats.passed += 1;
+            } else {
+                testItemIndex.setSubtestStats(parentTestCaseId, { failed: 0, passed: 1 });
+                clearAllChildren(parentTestItem);
+            }
+
+            const subTestItem = testController?.createTestItem(subtestId, subtestId, parentTestItem.uri);
+
+            if (subTestItem) {
+                parentTestItem.children.add(subTestItem);
+                runInstance.started(subTestItem);
+                runInstance.passed(subTestItem);
+            } else {
+                throw new Error('Unable to create new child node for subtest');
+            }
+        } else {
+            throw new Error('Parent test item not found');
+        }
+    }
+}
diff --git a/src/client/testing/testController/common/testItemIndex.ts b/src/client/testing/testController/common/testItemIndex.ts
new file mode 100644
index 000000000000..448903eae7d5
--- /dev/null
+++ b/src/client/testing/testController/common/testItemIndex.ts
@@ -0,0 +1,225 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestController, TestItem } from 'vscode';
+import { traceError, traceVerbose } from '../../../logging';
+import { getTestCaseNodes } from './testItemUtilities';
+
+export interface SubtestStats {
+    passed: number;
+    failed: number;
+}
+
+/**
+ * Maintains persistent ID mappings between Python test IDs and VS Code TestItems.
+ * This is a stateful component that bridges discovery and execution phases.
+ *
+ * Lifecycle:
+ * - Created: When PythonResultResolver is instantiated (during workspace activation)
+ * - Populated: During discovery - each discovered test registers its mappings
+ * - Queried: During execution - to look up TestItems by Python run ID
+ * - Cleared: When discovery runs again (fresh start) or workspace is disposed
+ * - Cleaned: Periodically to remove stale references to deleted tests
+ */
+export class TestItemIndex {
+    // THE STATE - these maps persist across discovery and execution
+    private runIdToTestItem: Map<string, TestItem>;
+    private runIdToVSid: Map<string, string>;
+    private vsIdToRunId: Map<string, string>;
+    private subtestStatsMap: Map<string, SubtestStats>;
+
+    constructor() {
+        this.runIdToTestItem = new Map<string, TestItem>();
+        this.runIdToVSid = new Map<string, string>();
+        this.vsIdToRunId = new Map<string, string>();
+        this.subtestStatsMap = new Map<string, SubtestStats>();
+    }
+
+    /**
+     * Register a test item with its Python run ID and VS Code ID
+     * Called during DISCOVERY to populate the index
+     */
+    public registerTestItem(runId: string, vsId: string, testItem: TestItem): void {
+        this.runIdToTestItem.set(runId, testItem);
+        this.runIdToVSid.set(runId, vsId);
+        this.vsIdToRunId.set(vsId, runId);
+    }
+
+    /**
+     * Get TestItem by Python run ID (with validation and fallback strategies)
+     * Called during EXECUTION to look up tests
+     *
+     * Uses a three-tier approach:
+     * 1. Direct O(1) lookup in runIdToTestItem map
+     * 2. If stale, try vsId mapping and search by VS Code ID
+     * 3. Last resort: full tree search
+     */
+    public getTestItem(runId: string, testController: TestController): TestItem | undefined {
+        // Try direct O(1) lookup first
+        const directItem = this.runIdToTestItem.get(runId);
+        if (directItem) {
+            // Validate the item is still in the test tree
+            if (this.isTestItemValid(directItem, testController)) {
+                return directItem;
+            } else {
+                // Clean up stale reference
+                this.runIdToTestItem.delete(runId);
+            }
+        }
+
+        // Try vsId mapping as fallback
+        const vsId = this.runIdToVSid.get(runId);
+        if (vsId) {
+            // Search by VS Code ID in the controller
+            let foundItem: TestItem | undefined;
+            testController.items.forEach((item) => {
+                if (item.id === vsId) {
+                    foundItem = item;
+                    return;
+                }
+                if (!foundItem) {
+                    item.children.forEach((child) => {
+                        if (child.id === vsId) {
+                            foundItem = child;
+                        }
+                    });
+                }
+            });
+
+            if (foundItem) {
+                // Cache for future lookups
+                this.runIdToTestItem.set(runId, foundItem);
+                return foundItem;
+            } else {
+                // Clean up stale mapping
+                this.runIdToVSid.delete(runId);
+                this.vsIdToRunId.delete(vsId);
+            }
+        }
+
+        // Last resort: full tree search
+        traceError(`Falling back to tree search for test: ${runId}`);
+        const testCases = this.collectAllTestCases(testController);
+        return testCases.find((item) => item.id === vsId);
+    }
+
+    /**
+     * Get Python run ID from VS Code ID
+     * Called by WorkspaceTestAdapter.executeTests() to convert selected tests to Python IDs
+     */
+    public getRunId(vsId: string): string | undefined {
+        return this.vsIdToRunId.get(vsId);
+    }
+
+    /**
+     * Get VS Code ID from Python run ID
+     */
+    public getVSId(runId: string): string | undefined {
+        return this.runIdToVSid.get(runId);
+    }
+
+    /**
+     * Check if a TestItem reference is still valid in the tree
+     *
+     * Time Complexity: O(depth) where depth is the maximum nesting level of the test tree.
+     * In most cases this is O(1) to O(3) since test trees are typically shallow.
+     */
+    public isTestItemValid(testItem: TestItem, testController: TestController): boolean {
+        // Simple validation: check if the item's parent chain leads back to the controller
+        let current: TestItem | undefined = testItem;
+        while (current?.parent) {
+            current = current.parent;
+        }
+
+        // If we reached a root item, check if it's in the controller
+        if (current) {
+            return testController.items.get(current.id) === current;
+        }
+
+        // If no parent chain, check if it's directly in the controller
+        return testController.items.get(testItem.id) === testItem;
+    }
+
+    /**
+     * Get subtest statistics for a parent test case
+     * Returns undefined if no stats exist yet for this parent
+     */
+    public getSubtestStats(parentId: string): SubtestStats | undefined {
+        return this.subtestStatsMap.get(parentId);
+    }
+
+    /**
+     * Set subtest statistics for a parent test case
+     */
+    public setSubtestStats(parentId: string, stats: SubtestStats): void {
+        this.subtestStatsMap.set(parentId, stats);
+    }
+
+    /**
+     * Remove all mappings
+     * Called at the start of discovery to ensure clean state
+     */
+    public clear(): void {
+        this.runIdToTestItem.clear();
+        this.runIdToVSid.clear();
+        this.vsIdToRunId.clear();
+        this.subtestStatsMap.clear();
+    }
+
+    /**
+     * Clean up stale references that no longer exist in the test tree
+     * Called after test tree modifications
+     */
+    public cleanupStaleReferences(testController: TestController): void {
+        const staleRunIds: string[] = [];
+
+        // Check all runId->TestItem mappings
+        this.runIdToTestItem.forEach((testItem, runId) => {
+            if (!this.isTestItemValid(testItem, testController)) {
+                staleRunIds.push(runId);
+            }
+        });
+
+        // Remove stale entries
+        staleRunIds.forEach((runId) => {
+            const vsId = this.runIdToVSid.get(runId);
+            this.runIdToTestItem.delete(runId);
+            this.runIdToVSid.delete(runId);
+            if (vsId) {
+                this.vsIdToRunId.delete(vsId);
+            }
+        });
+
+        if (staleRunIds.length > 0) {
+            traceVerbose(`Cleaned up ${staleRunIds.length} stale test item references`);
+        }
+    }
+
+    /**
+     * Collect all test case items from the test controller tree.
+     * Note: This performs full tree traversal - use cached lookups when possible.
+     */
+    private collectAllTestCases(testController: TestController): TestItem[] {
+        const testCases: TestItem[] = [];
+
+        testController.items.forEach((i) => {
+            const tempArr: TestItem[] = getTestCaseNodes(i);
+            testCases.push(...tempArr);
+        });
+
+        return testCases;
+    }
+
+    // Expose maps for backward compatibility (read-only access)
+    public get runIdToTestItemMap(): Map<string, TestItem> {
+        return this.runIdToTestItem;
+    }
+
+    public get runIdToVSidMap(): Map<string, string> {
+        return this.runIdToVSid;
+    }
+
+    public get vsIdToRunIdMap(): Map<string, string> {
+        return this.vsIdToRunId;
+    }
+}
diff --git a/src/client/testing/testController/common/testProjectRegistry.ts b/src/client/testing/testController/common/testProjectRegistry.ts
new file mode 100644
index 000000000000..4f0702ad584c
--- /dev/null
+++ b/src/client/testing/testController/common/testProjectRegistry.ts
@@ -0,0 +1,330 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as path from 'path';
+import { TestController, Uri } from 'vscode';
+import { isParentPath } from '../../../common/platform/fs-paths';
+import { IConfigurationService } from '../../../common/types';
+import { IInterpreterService } from '../../../interpreter/contracts';
+import { traceError, traceInfo } from '../../../logging';
+import { UNITTEST_PROVIDER } from '../../common/constants';
+import { TestProvider } from '../../types';
+import { IEnvironmentVariablesProvider } from '../../../common/variables/types';
+import { PythonProject, PythonEnvironment } from '../../../envExt/types';
+import { getEnvExtApi, useEnvExtension } from '../../../envExt/api.internal';
+import { ProjectAdapter } from './projectAdapter';
+import { getProjectId, createProjectDisplayName, createTestAdapters } from './projectUtils';
+import { PythonResultResolver } from './resultResolver';
+
+/**
+ * Registry for Python test projects within workspaces.
+ *
+ * Manages the lifecycle of test projects including:
+ * - Discovering Python projects via Python Environments API
+ * - Creating and storing ProjectAdapter instances per workspace
+ * - Computing nested project relationships for ignore lists
+ * - Fallback to default "legacy" project when API unavailable
+ *
+ * **Key concepts:**
+ * - **Workspace:** A VS Code workspace folder (may contain multiple projects)
+ * - **Project:** A Python project within a workspace (identified by pyproject.toml, setup.py, etc.)
+ * - **ProjectUri:** The unique identifier for a project (the URI of the project root directory)
+ * - Each project gets its own test tree root, Python environment, and test adapters
+ *
+ * **Project identification:**
+ * Projects are identified and tracked by their URI (projectUri.toString()). This matches
+ * how the Python Environments extension stores projects in its Map<string, PythonProject>.
+ */
+export class TestProjectRegistry {
+    /**
+     * Map of workspace URI -> Map of project URI string -> ProjectAdapter
+     *
+     * Projects are keyed by their URI string (projectUri.toString()) which matches how
+     * the Python Environments extension identifies projects. This enables O(1) lookups
+     * when given a project URI.
+     */
+    private readonly workspaceProjects: Map<Uri, Map<string, ProjectAdapter>> = new Map();
+
+    constructor(
+        private readonly testController: TestController,
+        private readonly configSettings: IConfigurationService,
+        private readonly interpreterService: IInterpreterService,
+        private readonly envVarsService: IEnvironmentVariablesProvider,
+    ) {}
+
+    /**
+     * Gets the projects map for a workspace, if it exists.
+     */
+    public getWorkspaceProjects(workspaceUri: Uri): Map<string, ProjectAdapter> | undefined {
+        return this.workspaceProjects.get(workspaceUri);
+    }
+
+    /**
+     * Checks if a workspace has been initialized with projects.
+     */
+    public hasProjects(workspaceUri: Uri): boolean {
+        return this.workspaceProjects.has(workspaceUri);
+    }
+
+    /**
+     * Gets all projects for a workspace as an array.
+     */
+    public getProjectsArray(workspaceUri: Uri): ProjectAdapter[] {
+        const projectsMap = this.workspaceProjects.get(workspaceUri);
+        return projectsMap ? Array.from(projectsMap.values()) : [];
+    }
+
+    /**
+     * Discovers and registers all Python projects for a workspace.
+     * Returns the discovered projects for the caller to use.
+     */
+    public async discoverAndRegisterProjects(workspaceUri: Uri): Promise<ProjectAdapter[]> {
+        traceInfo(`[test-by-project] Discovering projects for workspace: ${workspaceUri.fsPath}`);
+
+        const projects = await this.discoverProjects(workspaceUri);
+
+        // Create map for this workspace, keyed by project URI
+        const projectsMap = new Map<string, ProjectAdapter>();
+        projects.forEach((project) => {
+            projectsMap.set(getProjectId(project.projectUri), project);
+        });
+
+        this.workspaceProjects.set(workspaceUri, projectsMap);
+        traceInfo(`[test-by-project] Registered ${projects.length} project(s) for ${workspaceUri.fsPath}`);
+
+        return projects;
+    }
+
+    /**
+     * Computes and populates nested project ignore lists for all projects in a workspace.
+     * Must be called before discovery to ensure parent projects ignore nested children.
+     */
+    public configureNestedProjectIgnores(workspaceUri: Uri): void {
+        const projectIgnores = this.computeNestedProjectIgnores(workspaceUri);
+        const projects = this.getProjectsArray(workspaceUri);
+
+        for (const project of projects) {
+            const ignorePaths = projectIgnores.get(getProjectId(project.projectUri));
+            if (ignorePaths && ignorePaths.length > 0) {
+                project.nestedProjectPathsToIgnore = ignorePaths;
+                traceInfo(`[test-by-project] ${project.projectName} will ignore nested: ${ignorePaths.join(', ')}`);
+            }
+        }
+    }
+
+    /**
+     * Clears all projects for a workspace.
+     */
+    public clearWorkspace(workspaceUri: Uri): void {
+        this.workspaceProjects.delete(workspaceUri);
+    }
+
+    // ====== Private Methods ======
+
+    /**
+     * Discovers Python projects in a workspace using the Python Environment API.
+     * Falls back to creating a single default project if API is unavailable.
+     */
+    private async discoverProjects(workspaceUri: Uri): Promise<ProjectAdapter[]> {
+        try {
+            if (!useEnvExtension()) {
+                traceInfo('[test-by-project] Python Environments API not available, using default project');
+                return [await this.createDefaultProject(workspaceUri)];
+            }
+
+            const envExtApi = await getEnvExtApi();
+            const allProjects = envExtApi.getPythonProjects();
+            traceInfo(`[test-by-project] Found ${allProjects.length} total Python projects from API`);
+
+            // Filter to projects within this workspace
+            const workspaceProjects = allProjects.filter((project) =>
+                isParentPath(project.uri.fsPath, workspaceUri.fsPath),
+            );
+            traceInfo(`[test-by-project] Filtered to ${workspaceProjects.length} projects in workspace`);
+
+            if (workspaceProjects.length === 0) {
+                traceInfo('[test-by-project] No projects found, creating default project');
+                return [await this.createDefaultProject(workspaceUri)];
+            }
+
+            // Create ProjectAdapter for each discovered project
+            const adapters: ProjectAdapter[] = [];
+            for (const pythonProject of workspaceProjects) {
+                try {
+                    const adapter = await this.createProjectAdapter(pythonProject, workspaceUri);
+                    adapters.push(adapter);
+                } catch (error) {
+                    traceError(`[test-by-project] Failed to create adapter for ${pythonProject.uri.fsPath}:`, error);
+                }
+            }
+
+            if (adapters.length === 0) {
+                traceInfo('[test-by-project] All adapters failed, falling back to default project');
+                return [await this.createDefaultProject(workspaceUri)];
+            }
+
+            return adapters;
+        } catch (error) {
+            traceError('[test-by-project] Discovery failed, using default project:', error);
+            return [await this.createDefaultProject(workspaceUri)];
+        }
+    }
+
+    /**
+     * Creates a ProjectAdapter from a PythonProject.
+     *
+     * Each project gets its own isolated test infrastructure:
+     * - **ResultResolver:** Handles mapping test IDs and processing results for this project
+     * - **DiscoveryAdapter:** Discovers tests scoped to this project's root directory
+     * - **ExecutionAdapter:** Runs tests for this project using its Python environment
+     *
+     */
+    private async createProjectAdapter(pythonProject: PythonProject, workspaceUri: Uri): Promise<ProjectAdapter> {
+        const projectId = getProjectId(pythonProject.uri);
+        traceInfo(`[test-by-project] Creating adapter for: ${pythonProject.name} at ${projectId}`);
+
+        // Resolve Python environment
+        const envExtApi = await getEnvExtApi();
+        const pythonEnvironment = await envExtApi.getEnvironment(pythonProject.uri);
+        if (!pythonEnvironment) {
+            throw new Error(`No Python environment found for project ${projectId}`);
+        }
+
+        // Create test infrastructure
+        const testProvider = this.getTestProvider(workspaceUri);
+        const projectDisplayName = createProjectDisplayName(pythonProject.name, pythonEnvironment.version);
+        const resultResolver = new PythonResultResolver(
+            this.testController,
+            testProvider,
+            workspaceUri,
+            projectId,
+            pythonProject.name, // Use simple project name for test tree label (without version)
+        );
+        const { discoveryAdapter, executionAdapter } = createTestAdapters(
+            testProvider,
+            resultResolver,
+            this.configSettings,
+            this.envVarsService,
+        );
+
+        return {
+            projectName: projectDisplayName,
+            projectUri: pythonProject.uri,
+            workspaceUri,
+            pythonProject,
+            pythonEnvironment,
+            testProvider,
+            discoveryAdapter,
+            executionAdapter,
+            resultResolver,
+            isDiscovering: false,
+            isExecuting: false,
+        };
+    }
+
+    /**
+     * Creates a default project for legacy/fallback mode.
+     */
+    private async createDefaultProject(workspaceUri: Uri): Promise<ProjectAdapter> {
+        traceInfo(`[test-by-project] Creating default project for: ${workspaceUri.fsPath}`);
+
+        const testProvider = this.getTestProvider(workspaceUri);
+        const resultResolver = new PythonResultResolver(this.testController, testProvider, workspaceUri);
+        const { discoveryAdapter, executionAdapter } = createTestAdapters(
+            testProvider,
+            resultResolver,
+            this.configSettings,
+            this.envVarsService,
+        );
+
+        const interpreter = await this.interpreterService.getActiveInterpreter(workspaceUri);
+
+        const pythonEnvironment: PythonEnvironment = {
+            name: 'default',
+            displayName: interpreter?.displayName || 'Python',
+            shortDisplayName: interpreter?.displayName || 'Python',
+            displayPath: interpreter?.path || 'python',
+            version: interpreter?.version?.raw || '3.x',
+            environmentPath: Uri.file(interpreter?.path || 'python'),
+            sysPrefix: interpreter?.sysPrefix || '',
+            execInfo: { run: { executable: interpreter?.path || 'python' } },
+            envId: { id: 'default', managerId: 'default' },
+        };
+
+        const pythonProject: PythonProject = {
+            name: path.basename(workspaceUri.fsPath) || 'workspace',
+            uri: workspaceUri,
+        };
+
+        return {
+            projectName: pythonProject.name,
+            projectUri: workspaceUri,
+            workspaceUri,
+            pythonProject,
+            pythonEnvironment,
+            testProvider,
+            discoveryAdapter,
+            executionAdapter,
+            resultResolver,
+            isDiscovering: false,
+            isExecuting: false,
+        };
+    }
+
+    /**
+     * Identifies nested projects and returns ignore paths for parent projects.
+     *
+     * **Time complexity:** O(n²) where n is the number of projects in the workspace.
+     * For each project, checks all other projects to find nested relationships.
+     *
+     * Note: Uses path.normalize() to handle Windows path separator inconsistencies
+     * (e.g., paths from URI.fsPath may have mixed separators).
+     */
+    private computeNestedProjectIgnores(workspaceUri: Uri): Map<string, string[]> {
+        const ignoreMap = new Map<string, string[]>();
+        const projects = this.getProjectsArray(workspaceUri);
+
+        if (projects.length === 0) return ignoreMap;
+
+        for (const parent of projects) {
+            const nestedPaths: string[] = [];
+
+            for (const child of projects) {
+                // Skip self-comparison using URI
+                if (parent.projectUri.toString() === child.projectUri.toString()) continue;
+
+                // Normalize paths to handle Windows path separator inconsistencies
+                const parentNormalized = path.normalize(parent.projectUri.fsPath);
+                const childNormalized = path.normalize(child.projectUri.fsPath);
+
+                // Add trailing separator to ensure we match directory boundaries
+                const parentWithSep = parentNormalized.endsWith(path.sep)
+                    ? parentNormalized
+                    : parentNormalized + path.sep;
+                const childWithSep = childNormalized.endsWith(path.sep) ? childNormalized : childNormalized + path.sep;
+
+                // Check if child is inside parent (case-insensitive for Windows)
+                const childIsInsideParent = childWithSep.toLowerCase().startsWith(parentWithSep.toLowerCase());
+
+                if (childIsInsideParent) {
+                    nestedPaths.push(child.projectUri.fsPath);
+                    traceInfo(`[test-by-project] Nested: ${child.projectName} is inside ${parent.projectName}`);
+                }
+            }
+
+            if (nestedPaths.length > 0) {
+                ignoreMap.set(getProjectId(parent.projectUri), nestedPaths);
+            }
+        }
+
+        return ignoreMap;
+    }
+
+    /**
+     * Determines the test provider based on workspace settings.
+     */
+    private getTestProvider(workspaceUri: Uri): TestProvider {
+        const settings = this.configSettings.getSettings(workspaceUri);
+        return settings.testing.unittestEnabled ? UNITTEST_PROVIDER : 'pytest';
+    }
+}
diff --git a/src/client/testing/testController/common/types.ts b/src/client/testing/testController/common/types.ts
index 7139788a8177..017c41cf3d97 100644
--- a/src/client/testing/testController/common/types.ts
+++ b/src/client/testing/testController/common/types.ts
@@ -16,6 +16,7 @@ import {
 import { ITestDebugLauncher } from '../../common/types';
 import { IPythonExecutionFactory } from '../../../common/process/types';
 import { PythonEnvironment } from '../../../pythonEnvironments/info';
+import { ProjectAdapter } from './projectAdapter';
 
 export enum TestDataKinds {
     Workspace,
@@ -142,10 +143,18 @@ export type TestCommandOptions = {
 //     triggerRunDataReceivedEvent(data: DataReceivedEvent): void;
 //     triggerDiscoveryDataReceivedEvent(data: DataReceivedEvent): void;
 // }
-export interface ITestResultResolver {
+
+/**
+ * Test item mapping interface used by populateTestTree.
+ * Contains only the maps needed for building the test tree.
+ */
+export interface ITestItemMappings {
     runIdToVSid: Map<string, string>;
     runIdToTestItem: Map<string, TestItem>;
     vsIdToRunId: Map<string, string>;
+}
+
+export interface ITestResultResolver extends ITestItemMappings {
     detailedCoverageMap: Map<string, FileCoverageDetail[]>;
 
     resolveDiscovery(payload: DiscoveredTestPayload, token?: CancellationToken): void;
@@ -155,33 +164,31 @@ export interface ITestResultResolver {
     _resolveCoverage(payload: CoveragePayload, runInstance: TestRun): void;
 }
 export interface ITestDiscoveryAdapter {
-    // ** first line old method signature, second line new method signature
-    discoverTests(uri: Uri): Promise<void>;
     discoverTests(
         uri: Uri,
-        executionFactory?: IPythonExecutionFactory,
+        executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void>;
 }
 
 // interface for execution/runner adapter
 export interface ITestExecutionAdapter {
-    // ** first line old method signature, second line new method signature
-    runTests(uri: Uri, testIds: string[], profileKind?: boolean | TestRunProfileKind): Promise<void>;
     runTests(
         uri: Uri,
         testIds: string[],
-        profileKind?: boolean | TestRunProfileKind,
-        runInstance?: TestRun,
-        executionFactory?: IPythonExecutionFactory,
+        profileKind: boolean | TestRunProfileKind | undefined,
+        runInstance: TestRun,
+        executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void>;
 }
 
 // Same types as in python_files/unittestadapter/utils.py
-export type DiscoveredTestType = 'folder' | 'file' | 'class' | 'test';
+export type DiscoveredTestType = 'folder' | 'file' | 'class' | 'function' | 'test';
 
 export type DiscoveredTestCommon = {
     path: string;
@@ -192,12 +199,13 @@ export type DiscoveredTestCommon = {
 };
 
 export type DiscoveredTestItem = DiscoveredTestCommon & {
-    lineno: number;
+    lineno: number | string;
     runID: string;
 };
 
 export type DiscoveredTestNode = DiscoveredTestCommon & {
     children: (DiscoveredTestNode | DiscoveredTestItem)[];
+    lineno?: number | string;
 };
 
 export type DiscoveredTestPayload = {
@@ -222,6 +230,8 @@ export type FileCoverageMetrics = {
     lines_covered: number[];
     // eslint-disable-next-line camelcase
     lines_missed: number[];
+    executed_branches: number;
+    total_branches: number;
 };
 
 export type ExecutionTestPayload = {
diff --git a/src/client/testing/testController/common/utils.ts b/src/client/testing/testController/common/utils.ts
index 9923d7ec3e12..9782487d940b 100644
--- a/src/client/testing/testController/common/utils.ts
+++ b/src/client/testing/testController/common/utils.ts
@@ -13,23 +13,17 @@ import {
     DiscoveredTestNode,
     DiscoveredTestPayload,
     ExecutionTestPayload,
-    ITestResultResolver,
+    ITestItemMappings,
 } from './types';
 import { Deferred, createDeferred } from '../../../common/utils/async';
 import { createReaderPipe, generateRandomPipeName } from '../../../common/pipes/namedPipes';
 import { EXTENSION_ROOT_DIR } from '../../../constants';
+import { PROJECT_ID_SEPARATOR } from './projectUtils';
 
 export function fixLogLinesNoTrailing(content: string): string {
     const lines = content.split(/\r?\n/g);
     return `${lines.join('\r\n')}`;
 }
-
-export const MESSAGE_ON_TESTING_OUTPUT_MOVE =
-    'Starting now, all test run output will be sent to the Test Result panel,' +
-    ' while test discovery output will be sent to the "Python" output channel instead of the "Python Test Log" channel.' +
-    ' The "Python Test Log" channel will be deprecated within the next month.' +
-    ' See https://github.com/microsoft/vscode-python/wiki/New-Method-for-Output-Handling-in-Python-Testing for details.';
-
 export function createTestingDeferred(): Deferred<void> {
     return createDeferred<void>();
 }
@@ -181,12 +175,51 @@ export async function startDiscoveryNamedPipe(
     return pipeName;
 }
 
-export function buildErrorNodeOptions(uri: Uri, message: string, testType: string): ErrorTestItemOptions {
-    const labelText = testType === 'pytest' ? 'pytest Discovery Error' : 'Unittest Discovery Error';
+/**
+ * Extracts the missing module name from a ModuleNotFoundError or ImportError message.
+ * @param message The error message to parse
+ * @returns The module name if found, undefined otherwise
+ */
+function extractMissingModuleName(message: string): string | undefined {
+    // Match patterns like:
+    // - No module named 'requests'
+    // - No module named "requests"
+    // - ModuleNotFoundError: No module named 'requests'
+    // - ImportError: No module named requests
+    const patterns = [/No module named ['"]([^'"]+)['"]/, /No module named (\S+)/];
+
+    for (const pattern of patterns) {
+        const match = message.match(pattern);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+
+export function buildErrorNodeOptions(
+    uri: Uri,
+    message: string,
+    testType: string,
+    projectName?: string,
+): ErrorTestItemOptions {
+    let labelText = testType === 'pytest' ? 'pytest Discovery Error' : 'Unittest Discovery Error';
+    let errorMessage = message;
+
+    // Check for missing module errors and provide specific messaging
+    const missingModule = extractMissingModuleName(message);
+    if (missingModule) {
+        labelText = `Missing Module: ${missingModule}`;
+        errorMessage = `The module '${missingModule}' is not installed in the selected Python environment. Please install it to enable test discovery.`;
+    }
+
+    // Use project name for label if available (project-based testing), otherwise use folder name
+    const displayName = projectName ?? path.basename(uri.fsPath);
+
     return {
         id: `DiscoveryError:${uri.fsPath}`,
-        label: `${labelText} [${path.basename(uri.fsPath)}]`,
-        error: message,
+        label: `${labelText} [${displayName}]`,
+        error: errorMessage,
     };
 }
 
@@ -194,12 +227,18 @@ export function populateTestTree(
     testController: TestController,
     testTreeData: DiscoveredTestNode,
     testRoot: TestItem | undefined,
-    resultResolver: ITestResultResolver,
+    testItemMappings: ITestItemMappings,
     token?: CancellationToken,
+    projectId?: string,
+    projectName?: string,
 ): void {
     // If testRoot is undefined, use the info of the root item of testTreeData to create a test item, and append it to the test controller.
     if (!testRoot) {
-        testRoot = testController.createTestItem(testTreeData.path, testTreeData.name, Uri.file(testTreeData.path));
+        // Create project-scoped ID if projectId is provided
+        const rootId = projectId ? `${projectId}${PROJECT_ID_SEPARATOR}${testTreeData.path}` : testTreeData.path;
+        // Use "Project: {name}" label for project-based testing, otherwise use folder name
+        const rootLabel = projectName ? `Project: ${projectName}` : testTreeData.name;
+        testRoot = testController.createTestItem(rootId, rootLabel, Uri.file(testTreeData.path));
 
         testRoot.canResolveChildren = true;
         testRoot.tags = [RunTestTag, DebugTestTag];
@@ -211,33 +250,59 @@ export function populateTestTree(
     testTreeData.children.forEach((child) => {
         if (!token?.isCancellationRequested) {
             if (isTestItem(child)) {
-                const testItem = testController.createTestItem(child.id_, child.name, Uri.file(child.path));
+                // Create project-scoped vsId
+                const vsId = projectId ? `${projectId}${PROJECT_ID_SEPARATOR}${child.id_}` : child.id_;
+                const testItem = testController.createTestItem(vsId, child.name, Uri.file(child.path));
                 testItem.tags = [RunTestTag, DebugTestTag];
 
                 let range: Range | undefined;
                 if (child.lineno) {
-                    range = new Range(new Position(Number(child.lineno) - 1, 0), new Position(Number(child.lineno), 0));
+                    if (Number(child.lineno) === 0) {
+                        range = new Range(new Position(0, 0), new Position(0, 0));
+                    } else {
+                        range = new Range(
+                            new Position(Number(child.lineno) - 1, 0),
+                            new Position(Number(child.lineno), 0),
+                        );
+                    }
                 }
                 testItem.canResolveChildren = false;
                 testItem.range = range;
                 testItem.tags = [RunTestTag, DebugTestTag];
 
                 testRoot!.children.add(testItem);
-                // add to our map
-                resultResolver.runIdToTestItem.set(child.runID, testItem);
-                resultResolver.runIdToVSid.set(child.runID, child.id_);
-                resultResolver.vsIdToRunId.set(child.id_, child.runID);
+                // add to our map - use runID as key, vsId as value
+                testItemMappings.runIdToTestItem.set(child.runID, testItem);
+                testItemMappings.runIdToVSid.set(child.runID, vsId);
+                testItemMappings.vsIdToRunId.set(vsId, child.runID);
             } else {
-                let node = testController.items.get(child.path);
+                // Use project-scoped ID for non-test nodes and look up within the current root
+                const nodeId = projectId ? `${projectId}${PROJECT_ID_SEPARATOR}${child.id_}` : child.id_;
+                let node = testRoot!.children.get(nodeId);
 
                 if (!node) {
-                    node = testController.createTestItem(child.id_, child.name, Uri.file(child.path));
+                    node = testController.createTestItem(nodeId, child.name, Uri.file(child.path));
 
                     node.canResolveChildren = true;
                     node.tags = [RunTestTag, DebugTestTag];
+
+                    // Set range for class nodes (and other nodes) if lineno is available
+                    let range: Range | undefined;
+                    if ('lineno' in child && child.lineno) {
+                        if (Number(child.lineno) === 0) {
+                            range = new Range(new Position(0, 0), new Position(0, 0));
+                        } else {
+                            range = new Range(
+                                new Position(Number(child.lineno) - 1, 0),
+                                new Position(Number(child.lineno), 0),
+                            );
+                        }
+                        node.range = range;
+                    }
+
                     testRoot!.children.add(node);
                 }
-                populateTestTree(testController, child, node, resultResolver, token);
+                populateTestTree(testController, child, node, testItemMappings, token, projectId, projectName);
             }
         }
     });
diff --git a/src/client/testing/testController/controller.ts b/src/client/testing/testController/controller.ts
index 98a7f909a8e2..04de209c171d 100644
--- a/src/client/testing/testController/controller.ts
+++ b/src/client/testing/testController/controller.ts
@@ -25,7 +25,7 @@ import { IExtensionSingleActivationService } from '../../activation/types';
 import { ICommandManager, IWorkspaceService } from '../../common/application/types';
 import * as constants from '../../common/constants';
 import { IPythonExecutionFactory } from '../../common/process/types';
-import { IConfigurationService, IDisposableRegistry, ITestOutputChannel, Resource } from '../../common/types';
+import { IConfigurationService, IDisposableRegistry, Resource } from '../../common/types';
 import { DelayedTrigger, IDelayedTrigger } from '../../common/utils/delayTrigger';
 import { noop } from '../../common/utils/misc';
 import { IInterpreterService } from '../../interpreter/contracts';
@@ -36,22 +36,18 @@ import { PYTEST_PROVIDER, UNITTEST_PROVIDER } from '../common/constants';
 import { TestProvider } from '../types';
 import { createErrorTestItem, DebugTestTag, getNodeByUri, RunTestTag } from './common/testItemUtilities';
 import { buildErrorNodeOptions } from './common/utils';
-import {
-    ITestController,
-    ITestDiscoveryAdapter,
-    ITestFrameworkController,
-    TestRefreshOptions,
-    ITestExecutionAdapter,
-} from './common/types';
-import { UnittestTestDiscoveryAdapter } from './unittest/testDiscoveryAdapter';
-import { UnittestTestExecutionAdapter } from './unittest/testExecutionAdapter';
-import { PytestTestDiscoveryAdapter } from './pytest/pytestDiscoveryAdapter';
-import { PytestTestExecutionAdapter } from './pytest/pytestExecutionAdapter';
+import { ITestController, ITestFrameworkController, TestRefreshOptions } from './common/types';
 import { WorkspaceTestAdapter } from './workspaceTestAdapter';
 import { ITestDebugLauncher } from '../common/types';
 import { PythonResultResolver } from './common/resultResolver';
 import { onDidSaveTextDocument } from '../../common/vscodeApis/workspaceApis';
 import { IEnvironmentVariablesProvider } from '../../common/variables/types';
+import { ProjectAdapter } from './common/projectAdapter';
+import { TestProjectRegistry } from './common/testProjectRegistry';
+import { createTestAdapters, getProjectId } from './common/projectUtils';
+import { executeTestsForProjects } from './common/projectTestExecution';
+import { useEnvExtension, getEnvExtApi } from '../../envExt/api.internal';
+import { DidChangePythonProjectsEventArgs, PythonProject } from '../../envExt/types';
 
 // Types gymnastics to make sure that sendTriggerTelemetry only accepts the correct types.
 type EventPropertyType = IEventNamePropertyMapping[EventName.UNITTEST_DISCOVERY_TRIGGER];
@@ -62,8 +58,12 @@ type TriggerType = EventPropertyType[TriggerKeyType];
 export class PythonTestController implements ITestController, IExtensionSingleActivationService {
     public readonly supportedWorkspaceTypes = { untrustedWorkspace: false, virtualWorkspace: false };
 
+    // Legacy: Single workspace test adapter per workspace (backward compatibility)
     private readonly testAdapters: Map<Uri, WorkspaceTestAdapter> = new Map();
 
+    // Registry for multi-project testing (one registry instance manages all projects across workspaces)
+    private readonly projectRegistry: TestProjectRegistry;
+
     private readonly triggerTypes: TriggerType[] = [];
 
     private readonly testController: TestController;
@@ -98,7 +98,6 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         @inject(ICommandManager) private readonly commandManager: ICommandManager,
         @inject(IPythonExecutionFactory) private readonly pythonExecFactory: IPythonExecutionFactory,
         @inject(ITestDebugLauncher) private readonly debugLauncher: ITestDebugLauncher,
-        @inject(ITestOutputChannel) private readonly testOutputChannel: ITestOutputChannel,
         @inject(IEnvironmentVariablesProvider) private readonly envVarsService: IEnvironmentVariablesProvider,
     ) {
         this.refreshCancellation = new CancellationTokenSource();
@@ -106,6 +105,14 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         this.testController = tests.createTestController('python-tests', 'Python Tests');
         this.disposables.push(this.testController);
 
+        // Initialize project registry for multi-project testing support
+        this.projectRegistry = new TestProjectRegistry(
+            this.testController,
+            this.configSettings,
+            this.interpreterService,
+            this.envVarsService,
+        );
+
         const delayTrigger = new DelayedTrigger(
             (uri: Uri, invalidate: boolean) => {
                 this.refreshTestDataInternal(uri);
@@ -161,64 +168,260 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         };
     }
 
+    /**
+     * Determines the test provider (pytest or unittest) based on workspace settings.
+     */
+    private getTestProvider(workspaceUri: Uri): TestProvider {
+        const settings = this.configSettings.getSettings(workspaceUri);
+        return settings.testing.unittestEnabled ? UNITTEST_PROVIDER : PYTEST_PROVIDER;
+    }
+
+    /**
+     * Sets up file watchers for test discovery triggers.
+     */
+    private setupFileWatchers(workspace: WorkspaceFolder): void {
+        const settings = this.configSettings.getSettings(workspace.uri);
+        if (settings.testing.autoTestDiscoverOnSaveEnabled) {
+            traceVerbose(`Testing: Setting up watcher for ${workspace.uri.fsPath}`);
+            this.watchForSettingsChanges(workspace);
+            this.watchForTestContentChangeOnSave();
+        }
+    }
+
+    /**
+     * Activates the test controller for all workspaces.
+     *
+     * Two activation modes:
+     * 1. **Project-based mode** (when Python Environments API available):
+     * 2. **Legacy mode** (fallback):
+     *
+     * Uses `Promise.allSettled` for resilient multi-workspace activation:
+     */
     public async activate(): Promise<void> {
         const workspaces: readonly WorkspaceFolder[] = this.workspaceService.workspaceFolders || [];
+
+        // PROJECT-BASED MODE: Uses Python Environments API to discover projects
+        // Each project becomes its own test tree root with its own Python environment
+        if (useEnvExtension()) {
+            traceInfo('[test-by-project] Activating project-based testing mode');
+
+            // Discover projects in parallel across all workspaces
+            // Promise.allSettled ensures one workspace failure doesn't block others
+            const results = await Promise.allSettled(
+                Array.from(workspaces).map(async (workspace) => {
+                    // Queries Python Environments API and creates ProjectAdapter instances
+                    const projects = await this.projectRegistry.discoverAndRegisterProjects(workspace.uri);
+                    return { workspace, projectCount: projects.length };
+                }),
+            );
+
+            // Process results: successful workspaces get file watchers, failed ones fall back to legacy
+            results.forEach((result, index) => {
+                const workspace = workspaces[index];
+                if (result.status === 'fulfilled') {
+                    traceInfo(
+                        `[test-by-project] Activated ${result.value.projectCount} project(s) for ${workspace.uri.fsPath}`,
+                    );
+                    this.setupFileWatchers(workspace);
+                } else {
+                    // Graceful degradation: if project discovery fails, use legacy single-adapter mode
+                    traceError(`[test-by-project] Failed for ${workspace.uri.fsPath}:`, result.reason);
+                    this.activateLegacyWorkspace(workspace);
+                }
+            });
+            // Subscribe to project changes to update test tree when projects are added/removed
+            await this.subscribeToProjectChanges();
+            return;
+        }
+
+        // LEGACY MODE: Single WorkspaceTestAdapter per workspace (backward compatibility)
         workspaces.forEach((workspace) => {
-            const settings = this.configSettings.getSettings(workspace.uri);
+            this.activateLegacyWorkspace(workspace);
+        });
+    }
+
+    /**
+     * Subscribes to Python project changes from the Python Environments API.
+     * When projects are added or removed, updates the test tree accordingly.
+     */
+    private async subscribeToProjectChanges(): Promise<void> {
+        try {
+            const envExtApi = await getEnvExtApi();
+            this.disposables.push(
+                envExtApi.onDidChangePythonProjects((event: DidChangePythonProjectsEventArgs) => {
+                    this.handleProjectChanges(event).catch((error) => {
+                        traceError('[test-by-project] Error handling project changes:', error);
+                    });
+                }),
+            );
+            traceInfo('[test-by-project] Subscribed to Python project changes');
+        } catch (error) {
+            traceError('[test-by-project] Failed to subscribe to project changes:', error);
+        }
+    }
 
-            let discoveryAdapter: ITestDiscoveryAdapter;
-            let executionAdapter: ITestExecutionAdapter;
-            let testProvider: TestProvider;
-            let resultResolver: PythonResultResolver;
+    /**
+     * Handles changes to Python projects (added or removed).
+     * Cleans up stale test items and re-discovers projects and tests for affected workspaces.
+     */
+    private async handleProjectChanges(event: DidChangePythonProjectsEventArgs): Promise<void> {
+        const { added, removed } = event;
 
-            if (settings.testing.unittestEnabled) {
-                testProvider = UNITTEST_PROVIDER;
-                resultResolver = new PythonResultResolver(this.testController, testProvider, workspace.uri);
-                discoveryAdapter = new UnittestTestDiscoveryAdapter(
-                    this.configSettings,
-                    this.testOutputChannel,
-                    resultResolver,
-                    this.envVarsService,
-                );
-                executionAdapter = new UnittestTestExecutionAdapter(
-                    this.configSettings,
-                    this.testOutputChannel,
-                    resultResolver,
-                    this.envVarsService,
-                );
-            } else {
-                testProvider = PYTEST_PROVIDER;
-                resultResolver = new PythonResultResolver(this.testController, testProvider, workspace.uri);
-                discoveryAdapter = new PytestTestDiscoveryAdapter(
-                    this.configSettings,
-                    this.testOutputChannel,
-                    resultResolver,
-                    this.envVarsService,
-                );
-                executionAdapter = new PytestTestExecutionAdapter(
-                    this.configSettings,
-                    this.testOutputChannel,
-                    resultResolver,
-                    this.envVarsService,
-                );
+        if (added.length === 0 && removed.length === 0) {
+            return;
+        }
+
+        traceInfo(`[test-by-project] Project changes detected: ${added.length} added, ${removed.length} removed`);
+
+        // Find all affected workspaces
+        const affectedWorkspaces = new Set<WorkspaceFolder>();
+
+        const findWorkspace = (project: PythonProject): WorkspaceFolder | undefined => {
+            return this.workspaceService.getWorkspaceFolder(project.uri);
+        };
+
+        for (const project of [...added, ...removed]) {
+            const workspace = findWorkspace(project);
+            if (workspace) {
+                affectedWorkspaces.add(workspace);
             }
+        }
 
-            const workspaceTestAdapter = new WorkspaceTestAdapter(
-                testProvider,
-                discoveryAdapter,
-                executionAdapter,
-                workspace.uri,
-                resultResolver,
-            );
+        // For each affected workspace, clean up and re-discover
+        for (const workspace of affectedWorkspaces) {
+            traceInfo(`[test-by-project] Re-discovering projects for workspace: ${workspace.uri.fsPath}`);
+
+            // Get the current projects before clearing to know what to clean up
+            const existingProjects = this.projectRegistry.getProjectsArray(workspace.uri);
 
-            this.testAdapters.set(workspace.uri, workspaceTestAdapter);
+            // Remove ALL test items for the affected workspace's projects
+            // This ensures no stale items remain from deleted/changed projects
+            this.removeWorkspaceProjectTestItems(workspace.uri, existingProjects);
 
-            if (settings.testing.autoTestDiscoverOnSaveEnabled) {
-                traceVerbose(`Testing: Setting up watcher for ${workspace.uri.fsPath}`);
-                this.watchForSettingsChanges(workspace);
-                this.watchForTestContentChangeOnSave();
+            // Also explicitly remove test items for removed projects (in case they weren't tracked)
+            for (const project of removed) {
+                const projectWorkspace = findWorkspace(project);
+                if (projectWorkspace?.uri.toString() === workspace.uri.toString()) {
+                    this.removeProjectTestItems(project);
+                }
+            }
+
+            // Re-discover all projects and tests for the workspace in a single pass.
+            // discoverAllProjectsInWorkspace is responsible for clearing/re-registering
+            // projects and performing test discovery for the workspace.
+            await this.discoverAllProjectsInWorkspace(workspace.uri);
+        }
+    }
+
+    /**
+     * Removes all test items associated with projects in a workspace.
+     * Used to clean up stale items before re-discovery.
+     */
+    private removeWorkspaceProjectTestItems(workspaceUri: Uri, projects: ProjectAdapter[]): void {
+        const idsToRemove: string[] = [];
+
+        // Collect IDs of test items belonging to any project in this workspace
+        for (const project of projects) {
+            const projectIdPrefix = getProjectId(project.projectUri);
+            const projectFsPath = project.projectUri.fsPath;
+
+            this.testController.items.forEach((item) => {
+                // Match by project ID prefix (e.g., "file:///path@@vsc@@...")
+                if (item.id.startsWith(projectIdPrefix)) {
+                    idsToRemove.push(item.id);
+                }
+                // Match by fsPath in ID (legacy items might use path directly)
+                else if (item.id.includes(projectFsPath)) {
+                    idsToRemove.push(item.id);
+                }
+                // Match by item URI being within project directory
+                else if (item.uri && item.uri.fsPath.startsWith(projectFsPath)) {
+                    idsToRemove.push(item.id);
+                }
+            });
+        }
+
+        // Also remove any items whose URI is within the workspace (catch-all for edge cases)
+        this.testController.items.forEach((item) => {
+            if (
+                item.uri &&
+                this.workspaceService.getWorkspaceFolder(item.uri)?.uri.toString() === workspaceUri.toString()
+            ) {
+                if (!idsToRemove.includes(item.id)) {
+                    idsToRemove.push(item.id);
+                }
             }
         });
+
+        // Remove all collected items
+        for (const id of idsToRemove) {
+            this.testController.items.delete(id);
+        }
+
+        traceInfo(
+            `[test-by-project] Cleaned up ${idsToRemove.length} test items for workspace: ${workspaceUri.fsPath}`,
+        );
+    }
+
+    /**
+     * Removes test items associated with a specific project from the test controller.
+     * Matches items by project ID prefix, fsPath, or URI.
+     */
+    private removeProjectTestItems(project: PythonProject): void {
+        const projectId = getProjectId(project.uri);
+        const projectFsPath = project.uri.fsPath;
+        const idsToRemove: string[] = [];
+
+        // Find all root items that belong to this project
+        this.testController.items.forEach((item) => {
+            // Match by project ID prefix (e.g., "file:///path@@vsc@@...")
+            if (item.id.startsWith(projectId)) {
+                idsToRemove.push(item.id);
+            }
+            // Match by fsPath in ID (items might use path directly without URI prefix)
+            else if (item.id.startsWith(projectFsPath) || item.id.includes(projectFsPath)) {
+                idsToRemove.push(item.id);
+            }
+            // Match by item URI being within project directory
+            else if (item.uri && item.uri.fsPath.startsWith(projectFsPath)) {
+                idsToRemove.push(item.id);
+            }
+        });
+
+        for (const id of idsToRemove) {
+            this.testController.items.delete(id);
+            traceVerbose(`[test-by-project] Removed test item: ${id}`);
+        }
+
+        if (idsToRemove.length > 0) {
+            traceInfo(`[test-by-project] Removed ${idsToRemove.length} test items for project: ${project.name}`);
+        }
+    }
+
+    /**
+     * Activates testing for a workspace using the legacy single-adapter approach.
+     * Used for backward compatibility when project-based testing is disabled or unavailable.
+     */
+    private activateLegacyWorkspace(workspace: WorkspaceFolder): void {
+        const testProvider = this.getTestProvider(workspace.uri);
+        const resultResolver = new PythonResultResolver(this.testController, testProvider, workspace.uri);
+        const { discoveryAdapter, executionAdapter } = createTestAdapters(
+            testProvider,
+            resultResolver,
+            this.configSettings,
+            this.envVarsService,
+        );
+
+        const workspaceTestAdapter = new WorkspaceTestAdapter(
+            testProvider,
+            discoveryAdapter,
+            executionAdapter,
+            workspace.uri,
+            resultResolver,
+        );
+
+        this.testAdapters.set(workspace.uri, workspaceTestAdapter);
+        this.setupFileWatchers(workspace);
     }
 
     public refreshTestData(uri?: Resource, options?: TestRefreshOptions): Promise<void> {
@@ -258,101 +461,228 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
 
     private async refreshTestDataInternal(uri?: Resource): Promise<void> {
         this.refreshingStartedEvent.fire();
-        if (uri) {
-            const settings = this.configSettings.getSettings(uri);
-            const workspace = this.workspaceService.getWorkspaceFolder(uri);
-            traceInfo(`Discover tests for workspace name: ${workspace?.name} - uri: ${uri.fsPath}`);
-            // Ensure we send test telemetry if it gets disabled again
-            this.sendTestDisabledTelemetry = true;
-            // ** experiment to roll out NEW test discovery mechanism
-            if (settings.testing.pytestEnabled) {
-                if (workspace && workspace.uri) {
-                    const testAdapter = this.testAdapters.get(workspace.uri);
-                    if (testAdapter) {
-                        const testProviderInAdapter = testAdapter.getTestProvider();
-                        if (testProviderInAdapter !== 'pytest') {
-                            traceError('Test provider in adapter is not pytest. Please reload window.');
-                            this.surfaceErrorNode(
-                                workspace.uri,
-                                'Test provider types are not aligned, please reload your VS Code window.',
-                                'pytest',
-                            );
-                            return Promise.resolve();
-                        }
-                        await testAdapter.discoverTests(
-                            this.testController,
-                            this.refreshCancellation.token,
-                            this.pythonExecFactory,
-                            await this.interpreterService.getActiveInterpreter(workspace.uri),
-                        );
-                    } else {
-                        traceError('Unable to find test adapter for workspace.');
-                    }
-                } else {
-                    traceError('Unable to find workspace for given file');
-                }
-            } else if (settings.testing.unittestEnabled) {
-                if (workspace && workspace.uri) {
-                    const testAdapter = this.testAdapters.get(workspace.uri);
-                    if (testAdapter) {
-                        const testProviderInAdapter = testAdapter.getTestProvider();
-                        if (testProviderInAdapter !== 'unittest') {
-                            traceError('Test provider in adapter is not unittest. Please reload window.');
-                            this.surfaceErrorNode(
-                                workspace.uri,
-                                'Test provider types are not aligned, please reload your VS Code window.',
-                                'unittest',
-                            );
-                            return Promise.resolve();
-                        }
-                        await testAdapter.discoverTests(
-                            this.testController,
-                            this.refreshCancellation.token,
-                            this.pythonExecFactory,
-                            await this.interpreterService.getActiveInterpreter(workspace.uri),
-                        );
-                    } else {
-                        traceError('Unable to find test adapter for workspace.');
-                    }
-                } else {
-                    traceError('Unable to find workspace for given file');
-                }
+        try {
+            if (uri) {
+                await this.discoverTestsInWorkspace(uri);
             } else {
-                if (this.sendTestDisabledTelemetry) {
-                    this.sendTestDisabledTelemetry = false;
-                    sendTelemetryEvent(EventName.UNITTEST_DISABLED);
-                }
-                // If we are here we may have to remove an existing node from the tree
-                // This handles the case where user removes test settings. Which should remove the
-                // tests for that particular case from the tree view
-                if (workspace) {
-                    const toDelete: string[] = [];
-                    this.testController.items.forEach((i: TestItem) => {
-                        const w = this.workspaceService.getWorkspaceFolder(i.uri);
-                        if (w?.uri.fsPath === workspace.uri.fsPath) {
-                            toDelete.push(i.id);
-                        }
-                    });
-                    toDelete.forEach((i) => this.testController.items.delete(i));
-                }
+                await this.discoverTestsInAllWorkspaces();
             }
-        } else {
-            traceVerbose('Testing: Refreshing all test data');
-            const workspaces: readonly WorkspaceFolder[] = this.workspaceService.workspaceFolders || [];
-            await Promise.all(
-                workspaces.map(async (workspace) => {
+        } finally {
+            this.refreshingCompletedEvent.fire();
+        }
+    }
+
+    /**
+     * Discovers tests for a single workspace.
+     *
+     * **Discovery flow:**
+     * 1. If the workspace has registered projects (via Python Environments API),
+     *    uses project-based discovery: each project is discovered independently
+     *    with its own Python environment and test adapters.
+     * 2. Otherwise, falls back to legacy mode: a single WorkspaceTestAdapter
+     *    discovers all tests in the workspace using the active interpreter.
+     *
+     * In project-based mode, the test tree will have separate roots for each project.
+     * In legacy mode, the workspace folder is the single test tree root.
+     */
+    private async discoverTestsInWorkspace(uri: Uri): Promise<void> {
+        const workspace = this.workspaceService.getWorkspaceFolder(uri);
+        if (!workspace?.uri) {
+            traceError('Unable to find workspace for given file');
+            return;
+        }
+
+        const settings = this.configSettings.getSettings(uri);
+        traceVerbose(`Discover tests for workspace name: ${workspace.name} - uri: ${uri.fsPath}`);
+
+        // Ensure we send test telemetry if it gets disabled again
+        this.sendTestDisabledTelemetry = true;
+
+        // Check if any test framework is enabled BEFORE project-based discovery
+        // This ensures the config screen stays visible when testing is disabled
+        if (!settings.testing.pytestEnabled && !settings.testing.unittestEnabled) {
+            await this.handleNoTestProviderEnabled(workspace);
+            return;
+        }
+
+        // Use project-based discovery if applicable (only reached if testing is enabled)
+        if (this.projectRegistry.hasProjects(workspace.uri)) {
+            await this.discoverAllProjectsInWorkspace(workspace.uri);
+            return;
+        }
+
+        // Legacy mode: Single workspace adapter
+        if (settings.testing.pytestEnabled) {
+            await this.discoverWorkspaceTestsLegacy(workspace.uri, 'pytest');
+        } else if (settings.testing.unittestEnabled) {
+            await this.discoverWorkspaceTestsLegacy(workspace.uri, 'unittest');
+        }
+    }
+
+    /**
+     * Discovers tests for all projects within a workspace (project-based mode).
+     * Re-discovers projects from the Python Environments API before running test discovery.
+     * This ensures the test tree stays in sync with project changes.
+     */
+    private async discoverAllProjectsInWorkspace(workspaceUri: Uri): Promise<void> {
+        // Defensive check: ensure testing is enabled (should be checked by caller, but be safe)
+        const settings = this.configSettings.getSettings(workspaceUri);
+        if (!settings.testing.pytestEnabled && !settings.testing.unittestEnabled) {
+            traceVerbose('[test-by-project] Skipping discovery - no test framework enabled');
+            return;
+        }
+
+        // Get existing projects before re-discovery for cleanup
+        const existingProjects = this.projectRegistry.getProjectsArray(workspaceUri);
+
+        // Clean up all existing test items for this workspace
+        // This ensures stale items from deleted/changed projects are removed
+        this.removeWorkspaceProjectTestItems(workspaceUri, existingProjects);
+
+        // Re-discover projects from Python Environments API
+        // This picks up any added/removed projects since last discovery
+        this.projectRegistry.clearWorkspace(workspaceUri);
+        const projects = await this.projectRegistry.discoverAndRegisterProjects(workspaceUri);
+
+        if (projects.length === 0) {
+            traceError(`[test-by-project] No projects found for workspace: ${workspaceUri.fsPath}`);
+            return;
+        }
+
+        traceInfo(`[test-by-project] Starting discovery for ${projects.length} project(s) in workspace`);
+
+        try {
+            // Configure nested project exclusions before discovery
+            this.projectRegistry.configureNestedProjectIgnores(workspaceUri);
+
+            // Track completion for progress logging
+            const projectsCompleted = new Set<string>();
+
+            // Run discovery for all projects in parallel
+            await Promise.all(projects.map((project) => this.discoverTestsForProject(project, projectsCompleted)));
+
+            traceInfo(
+                `[test-by-project] Discovery complete: ${projectsCompleted.size}/${projects.length} projects completed`,
+            );
+        } catch (error) {
+            traceError(`[test-by-project] Discovery failed for workspace ${workspaceUri.fsPath}:`, error);
+        }
+    }
+
+    /**
+     * Discovers tests for a single project (project-based mode).
+     * Creates test tree items rooted at the project's directory.
+     */
+    private async discoverTestsForProject(project: ProjectAdapter, projectsCompleted: Set<string>): Promise<void> {
+        try {
+            traceInfo(`[test-by-project] Discovering tests for project: ${project.projectName}`);
+            project.isDiscovering = true;
+
+            // In project-based mode, the discovery adapter uses the Python Environments API
+            // to get the environment directly, so we don't need to pass the interpreter
+            await project.discoveryAdapter.discoverTests(
+                project.projectUri,
+                this.pythonExecFactory,
+                this.refreshCancellation.token,
+                undefined, // Interpreter not needed; adapter uses Python Environments API
+                project,
+            );
+
+            // Mark project as completed (use URI string as unique key)
+            projectsCompleted.add(project.projectUri.toString());
+            traceInfo(`[test-by-project] Project ${project.projectName} discovery completed`);
+        } catch (error) {
+            traceError(`[test-by-project] Discovery failed for project ${project.projectName}:`, error);
+            // Individual project failures don't block others
+            projectsCompleted.add(project.projectUri.toString()); // Still mark as completed
+        } finally {
+            project.isDiscovering = false;
+        }
+    }
+
+    /**
+     * Discovers tests across all workspace folders.
+     * Iterates each workspace and triggers discovery.
+     */
+    private async discoverTestsInAllWorkspaces(): Promise<void> {
+        traceVerbose('Testing: Refreshing all test data');
+        const workspaces: readonly WorkspaceFolder[] = this.workspaceService.workspaceFolders || [];
+
+        await Promise.all(
+            workspaces.map(async (workspace) => {
+                // In project-based mode, each project has its own environment,
+                // so we don't require a global active interpreter
+                if (!useEnvExtension()) {
                     if (!(await this.interpreterService.getActiveInterpreter(workspace.uri))) {
                         this.commandManager
                             .executeCommand(constants.Commands.TriggerEnvironmentSelection, workspace.uri)
                             .then(noop, noop);
                         return;
                     }
-                    await this.refreshTestDataInternal(workspace.uri);
-                }),
+                }
+                await this.discoverTestsInWorkspace(workspace.uri);
+            }),
+        );
+    }
+
+    /**
+     * Discovers tests for a workspace using legacy single-adapter mode.
+     */
+    private async discoverWorkspaceTestsLegacy(workspaceUri: Uri, expectedProvider: TestProvider): Promise<void> {
+        const testAdapter = this.testAdapters.get(workspaceUri);
+
+        if (!testAdapter) {
+            traceError('Unable to find test adapter for workspace.');
+            return;
+        }
+
+        const actualProvider = testAdapter.getTestProvider();
+        if (actualProvider !== expectedProvider) {
+            traceError(`Test provider in adapter is not ${expectedProvider}. Please reload window.`);
+            this.surfaceErrorNode(
+                workspaceUri,
+                'Test provider types are not aligned, please reload your VS Code window.',
+                expectedProvider,
             );
+            return;
         }
-        this.refreshingCompletedEvent.fire();
-        return Promise.resolve();
+
+        await testAdapter.discoverTests(
+            this.testController,
+            this.pythonExecFactory,
+            this.refreshCancellation.token,
+            await this.interpreterService.getActiveInterpreter(workspaceUri),
+        );
+    }
+
+    /**
+     * Handles the case when no test provider is enabled.
+     * Sends telemetry and removes test items for the workspace from the tree.
+     */
+    private async handleNoTestProviderEnabled(workspace: WorkspaceFolder): Promise<void> {
+        if (this.sendTestDisabledTelemetry) {
+            this.sendTestDisabledTelemetry = false;
+            sendTelemetryEvent(EventName.UNITTEST_DISABLED);
+        }
+
+        this.removeTestItemsForWorkspace(workspace);
+    }
+
+    /**
+     * Removes all test items belonging to a specific workspace from the test controller.
+     * This is used when test discovery is disabled for a workspace.
+     */
+    private removeTestItemsForWorkspace(workspace: WorkspaceFolder): void {
+        const itemsToDelete: string[] = [];
+
+        this.testController.items.forEach((testItem: TestItem) => {
+            const itemWorkspace = this.workspaceService.getWorkspaceFolder(testItem.uri);
+            if (itemWorkspace?.uri.fsPath === workspace.uri.fsPath) {
+                itemsToDelete.push(testItem.id);
+            }
+        });
+
+        itemsToDelete.forEach((id) => this.testController.items.delete(id));
     }
 
     private async resolveChildren(item: TestItem | undefined): Promise<void> {
@@ -371,9 +701,13 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
             const workspaces: readonly WorkspaceFolder[] = this.workspaceService.workspaceFolders || [];
             await Promise.all(
                 workspaces.map(async (workspace) => {
-                    if (!(await this.interpreterService.getActiveInterpreter(workspace.uri))) {
-                        traceError('Cannot trigger test discovery as a valid interpreter is not selected');
-                        return;
+                    // In project-based mode, each project has its own environment,
+                    // so we don't require a global active interpreter
+                    if (!useEnvExtension()) {
+                        if (!(await this.interpreterService.getActiveInterpreter(workspace.uri))) {
+                            traceError('Cannot trigger test discovery as a valid interpreter is not selected');
+                            return;
+                        }
                     }
                     await this.refreshTestDataInternal(workspace.uri);
                 }),
@@ -383,21 +717,13 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
     }
 
     private async runTests(request: TestRunRequest, token: CancellationToken): Promise<void> {
-        const workspaces: WorkspaceFolder[] = [];
-        if (request.include) {
-            uniq(request.include.map((r) => this.workspaceService.getWorkspaceFolder(r.uri))).forEach((w) => {
-                if (w) {
-                    workspaces.push(w);
-                }
-            });
-        } else {
-            (this.workspaceService.workspaceFolders || []).forEach((w) => workspaces.push(w));
-        }
+        const workspaces = this.getWorkspacesForTestRun(request);
         const runInstance = this.testController.createTestRun(
             request,
             `Running Tests for Workspace(s): ${workspaces.map((w) => w.uri.fsPath).join(';')}`,
             true,
         );
+
         const dispose = token.onCancellationRequested(() => {
             runInstance.appendOutput(`\nRun instance cancelled.\r\n`);
             runInstance.end();
@@ -407,87 +733,9 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
 
         try {
             await Promise.all(
-                workspaces.map(async (workspace) => {
-                    if (!(await this.interpreterService.getActiveInterpreter(workspace.uri))) {
-                        this.commandManager
-                            .executeCommand(constants.Commands.TriggerEnvironmentSelection, workspace.uri)
-                            .then(noop, noop);
-                        return undefined;
-                    }
-                    const testItems: TestItem[] = [];
-                    // If the run request includes test items then collect only items that belong to
-                    // `workspace`. If there are no items in the run request then just run the `workspace`
-                    // root test node. Include will be `undefined` in the "run all" scenario.
-                    (request.include ?? this.testController.items).forEach((i: TestItem) => {
-                        const w = this.workspaceService.getWorkspaceFolder(i.uri);
-                        if (w?.uri.fsPath === workspace.uri.fsPath) {
-                            testItems.push(i);
-                        }
-                    });
-
-                    const settings = this.configSettings.getSettings(workspace.uri);
-                    if (testItems.length > 0) {
-                        const testAdapter =
-                            this.testAdapters.get(workspace.uri) ||
-                            (this.testAdapters.values().next().value as WorkspaceTestAdapter);
-
-                        // no profile will have TestRunProfileKind.Coverage if rewrite isn't enabled
-                        if (request.profile?.kind && request.profile?.kind === TestRunProfileKind.Coverage) {
-                            request.profile.loadDetailedCoverage = (
-                                _testRun: TestRun,
-                                fileCoverage,
-                                _token,
-                            ): Thenable<FileCoverageDetail[]> => {
-                                const details = testAdapter.resultResolver.detailedCoverageMap.get(
-                                    fileCoverage.uri.fsPath,
-                                );
-                                if (details === undefined) {
-                                    // given file has no detailed coverage data
-                                    return Promise.resolve([]);
-                                }
-                                return Promise.resolve(details);
-                            };
-                        }
-
-                        if (settings.testing.pytestEnabled) {
-                            sendTelemetryEvent(EventName.UNITTEST_RUN, undefined, {
-                                tool: 'pytest',
-                                debugging: request.profile?.kind === TestRunProfileKind.Debug,
-                            });
-                            return testAdapter.executeTests(
-                                this.testController,
-                                runInstance,
-                                testItems,
-                                token,
-                                request.profile?.kind,
-                                this.pythonExecFactory,
-                                this.debugLauncher,
-                                await this.interpreterService.getActiveInterpreter(workspace.uri),
-                            );
-                        }
-                        if (settings.testing.unittestEnabled) {
-                            sendTelemetryEvent(EventName.UNITTEST_RUN, undefined, {
-                                tool: 'unittest',
-                                debugging: request.profile?.kind === TestRunProfileKind.Debug,
-                            });
-                            // ** experiment to roll out NEW test discovery mechanism
-                            return testAdapter.executeTests(
-                                this.testController,
-                                runInstance,
-                                testItems,
-                                token,
-                                request.profile?.kind,
-                                this.pythonExecFactory,
-                                this.debugLauncher,
-                                await this.interpreterService.getActiveInterpreter(workspace.uri),
-                            );
-                        }
-                    }
-                    if (!settings.testing.pytestEnabled && !settings.testing.unittestEnabled) {
-                        unconfiguredWorkspaces.push(workspace);
-                    }
-                    return Promise.resolve();
-                }),
+                workspaces.map((workspace) =>
+                    this.runTestsForWorkspace(workspace, request, runInstance, token, unconfiguredWorkspaces),
+                ),
             );
         } finally {
             traceVerbose('Finished running tests, ending runInstance.');
@@ -500,6 +748,168 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         }
     }
 
+    /**
+     * Gets the list of workspaces to run tests for based on the test run request.
+     */
+    private getWorkspacesForTestRun(request: TestRunRequest): WorkspaceFolder[] {
+        if (request.include) {
+            const workspaces: WorkspaceFolder[] = [];
+            uniq(request.include.map((r) => this.workspaceService.getWorkspaceFolder(r.uri))).forEach((w) => {
+                if (w) {
+                    workspaces.push(w);
+                }
+            });
+            return workspaces;
+        }
+        return Array.from(this.workspaceService.workspaceFolders || []);
+    }
+
+    /**
+     * Runs tests for a single workspace.
+     */
+    private async runTestsForWorkspace(
+        workspace: WorkspaceFolder,
+        request: TestRunRequest,
+        runInstance: TestRun,
+        token: CancellationToken,
+        unconfiguredWorkspaces: WorkspaceFolder[],
+    ): Promise<void> {
+        if (!(await this.interpreterService.getActiveInterpreter(workspace.uri))) {
+            this.commandManager
+                .executeCommand(constants.Commands.TriggerEnvironmentSelection, workspace.uri)
+                .then(noop, noop);
+            return;
+        }
+
+        const testItems = this.getTestItemsForWorkspace(workspace, request);
+        const settings = this.configSettings.getSettings(workspace.uri);
+
+        if (testItems.length === 0) {
+            if (!settings.testing.pytestEnabled && !settings.testing.unittestEnabled) {
+                unconfiguredWorkspaces.push(workspace);
+            }
+            return;
+        }
+
+        // Check if we're in project-based mode and should use project-specific execution
+        if (this.projectRegistry.hasProjects(workspace.uri)) {
+            const projects = this.projectRegistry.getProjectsArray(workspace.uri);
+            await executeTestsForProjects(projects, testItems, runInstance, request, token, {
+                projectRegistry: this.projectRegistry,
+                pythonExecFactory: this.pythonExecFactory,
+                debugLauncher: this.debugLauncher,
+            });
+            return;
+        }
+
+        // For unittest (or pytest when not in project mode), use the legacy WorkspaceTestAdapter.
+        // In project mode, legacy adapters may not be initialized, so create one on demand.
+        let testAdapter = this.testAdapters.get(workspace.uri);
+        if (!testAdapter) {
+            // Initialize legacy adapter on demand (needed for unittest in project mode)
+            this.activateLegacyWorkspace(workspace);
+            testAdapter = this.testAdapters.get(workspace.uri);
+        }
+
+        if (!testAdapter) {
+            traceError(`[test] No test adapter available for workspace: ${workspace.uri.fsPath}`);
+            return;
+        }
+
+        this.setupCoverageIfNeeded(request, testAdapter);
+
+        if (settings.testing.pytestEnabled) {
+            await this.executeTestsForProvider(
+                workspace,
+                testAdapter,
+                testItems,
+                runInstance,
+                request,
+                token,
+                'pytest',
+            );
+        } else if (settings.testing.unittestEnabled) {
+            await this.executeTestsForProvider(
+                workspace,
+                testAdapter,
+                testItems,
+                runInstance,
+                request,
+                token,
+                'unittest',
+            );
+        } else {
+            unconfiguredWorkspaces.push(workspace);
+        }
+    }
+
+    /**
+     * Gets test items that belong to a specific workspace from the run request.
+     */
+    private getTestItemsForWorkspace(workspace: WorkspaceFolder, request: TestRunRequest): TestItem[] {
+        const testItems: TestItem[] = [];
+        // If the run request includes test items then collect only items that belong to
+        // `workspace`. If there are no items in the run request then just run the `workspace`
+        // root test node. Include will be `undefined` in the "run all" scenario.
+        (request.include ?? this.testController.items).forEach((i: TestItem) => {
+            const w = this.workspaceService.getWorkspaceFolder(i.uri);
+            if (w?.uri.fsPath === workspace.uri.fsPath) {
+                testItems.push(i);
+            }
+        });
+        return testItems;
+    }
+
+    /**
+     * Sets up detailed coverage loading if the run profile is for coverage.
+     */
+    private setupCoverageIfNeeded(request: TestRunRequest, testAdapter: WorkspaceTestAdapter): void {
+        // no profile will have TestRunProfileKind.Coverage if rewrite isn't enabled
+        if (request.profile?.kind && request.profile?.kind === TestRunProfileKind.Coverage) {
+            request.profile.loadDetailedCoverage = (
+                _testRun: TestRun,
+                fileCoverage,
+                _token,
+            ): Thenable<FileCoverageDetail[]> => {
+                const details = testAdapter.resultResolver.detailedCoverageMap.get(fileCoverage.uri.fsPath);
+                if (details === undefined) {
+                    // given file has no detailed coverage data
+                    return Promise.resolve([]);
+                }
+                return Promise.resolve(details);
+            };
+        }
+    }
+
+    /**
+     * Executes tests using the test adapter for a specific test provider.
+     */
+    private async executeTestsForProvider(
+        workspace: WorkspaceFolder,
+        testAdapter: WorkspaceTestAdapter,
+        testItems: TestItem[],
+        runInstance: TestRun,
+        request: TestRunRequest,
+        token: CancellationToken,
+        provider: TestProvider,
+    ): Promise<void> {
+        sendTelemetryEvent(EventName.UNITTEST_RUN, undefined, {
+            tool: provider,
+            debugging: request.profile?.kind === TestRunProfileKind.Debug,
+        });
+
+        await testAdapter.executeTests(
+            this.testController,
+            runInstance,
+            testItems,
+            this.pythonExecFactory,
+            token,
+            request.profile?.kind,
+            this.debugLauncher,
+            await this.interpreterService.getActiveInterpreter(workspace.uri),
+        );
+    }
+
     private invalidateTests(uri: Uri) {
         this.testController.items.forEach((root) => {
             const item = getNodeByUri(root, uri);
@@ -554,7 +964,10 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         this.disposables.push(
             onDidSaveTextDocument(async (doc: TextDocument) => {
                 const settings = this.configSettings.getSettings(doc.uri);
-                if (minimatch.default(doc.uri.fsPath, settings.testing.autoTestDiscoverOnSavePattern)) {
+                if (
+                    settings.testing.autoTestDiscoverOnSaveEnabled &&
+                    minimatch.default(doc.uri.fsPath, settings.testing.autoTestDiscoverOnSavePattern)
+                ) {
                     traceVerbose(`Testing: Trigger refresh after saving ${doc.uri.fsPath}`);
                     this.sendTriggerTelemetry('watching');
                     this.refreshData.trigger(doc.uri, false);
diff --git a/src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts b/src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts
index 71d71997c57e..16e27635e66c 100644
--- a/src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts
+++ b/src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts
@@ -1,236 +1,225 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 import * as path from 'path';
-import { CancellationToken, CancellationTokenSource, Uri } from 'vscode';
-import * as fs from 'fs';
+import { CancellationToken, Disposable, Uri } from 'vscode';
 import { ChildProcess } from 'child_process';
 import {
     ExecutionFactoryCreateWithEnvironmentOptions,
     IPythonExecutionFactory,
     SpawnOptions,
 } from '../../../common/process/types';
-import { IConfigurationService, ITestOutputChannel } from '../../../common/types';
-import { createDeferred, Deferred } from '../../../common/utils/async';
+import { IConfigurationService } from '../../../common/types';
+import { Deferred } from '../../../common/utils/async';
 import { EXTENSION_ROOT_DIR } from '../../../constants';
-import { traceError, traceInfo, traceVerbose, traceWarn } from '../../../logging';
-import { DiscoveredTestPayload, ITestDiscoveryAdapter, ITestResultResolver } from '../common/types';
-import {
-    MESSAGE_ON_TESTING_OUTPUT_MOVE,
-    createDiscoveryErrorPayload,
-    createTestingDeferred,
-    fixLogLinesNoTrailing,
-    startDiscoveryNamedPipe,
-    addValueIfKeyNotExist,
-    hasSymlinkParent,
-} from '../common/utils';
+import { traceError, traceInfo, traceVerbose } from '../../../logging';
+import { ITestDiscoveryAdapter, ITestResultResolver } from '../common/types';
+import { createTestingDeferred } from '../common/utils';
 import { IEnvironmentVariablesProvider } from '../../../common/variables/types';
 import { PythonEnvironment } from '../../../pythonEnvironments/info';
 import { useEnvExtension, getEnvironment, runInBackground } from '../../../envExt/api.internal';
+import { buildPytestEnv as configureSubprocessEnv, handleSymlinkAndRootDir } from './pytestHelpers';
+import { cleanupOnCancellation, createProcessHandlers, setupDiscoveryPipe } from '../common/discoveryHelpers';
+import { ProjectAdapter } from '../common/projectAdapter';
+
+/**
+ * Configures the subprocess environment for pytest discovery.
+ * @param envVarsService Service to retrieve environment variables
+ * @param uri Workspace URI
+ * @param discoveryPipeName Name of the discovery pipe to pass to the subprocess
+ * @returns Configured environment variables for the subprocess
+ */
+async function configureDiscoveryEnv(
+    envVarsService: IEnvironmentVariablesProvider | undefined,
+    uri: Uri,
+    discoveryPipeName: string,
+): Promise<NodeJS.ProcessEnv> {
+    const fullPluginPath = path.join(EXTENSION_ROOT_DIR, 'python_files');
+    const envVars = await envVarsService?.getEnvironmentVariables(uri);
+    const mutableEnv = configureSubprocessEnv(envVars, fullPluginPath, discoveryPipeName);
+    return mutableEnv;
+}
 
 /**
- * Wrapper class for unittest test discovery. This is where we call `runTestCommand`. #this seems incorrectly copied
+ * Wrapper class for pytest test discovery. This is where we call the pytest subprocess.
  */
 export class PytestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
     constructor(
         public configSettings: IConfigurationService,
-        private readonly outputChannel: ITestOutputChannel,
         private readonly resultResolver?: ITestResultResolver,
         private readonly envVarsService?: IEnvironmentVariablesProvider,
     ) {}
 
     async discoverTests(
         uri: Uri,
-        executionFactory?: IPythonExecutionFactory,
+        executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
-        const cSource = new CancellationTokenSource();
-        const deferredReturn = createDeferred<void>();
-
-        token?.onCancellationRequested(() => {
-            traceInfo(`Test discovery cancelled.`);
-            cSource.cancel();
-            deferredReturn.resolve();
-        });
-
-        const name = await startDiscoveryNamedPipe((data: DiscoveredTestPayload) => {
-            // if the token is cancelled, we don't want process the data
-            if (!token?.isCancellationRequested) {
-                this.resultResolver?.resolveDiscovery(data);
-            }
-        }, cSource.token);
+        // Setup discovery pipe and cancellation
+        const {
+            pipeName: discoveryPipeName,
+            cancellation: discoveryPipeCancellation,
+            tokenDisposable,
+        } = await setupDiscoveryPipe(this.resultResolver, token, uri);
+
+        // Setup process handlers deferred (used by both execution paths)
+        const deferredTillExecClose: Deferred<void> = createTestingDeferred();
 
-        this.runPytestDiscovery(uri, name, cSource, executionFactory, interpreter, token).then(() => {
-            deferredReturn.resolve();
-        });
+        // Collect all disposables related to discovery to handle cleanup in finally block
+        const disposables: Disposable[] = [];
+        if (tokenDisposable) {
+            disposables.push(tokenDisposable);
+        }
 
-        return deferredReturn.promise;
-    }
+        try {
+            // Build pytest command and arguments
+            const settings = this.configSettings.getSettings(uri);
+            let { pytestArgs } = settings.testing;
+            const cwd = settings.testing.cwd && settings.testing.cwd.length > 0 ? settings.testing.cwd : uri.fsPath;
+            pytestArgs = await handleSymlinkAndRootDir(cwd, pytestArgs);
+
+            // Add --ignore flags for nested projects to prevent duplicate discovery
+            if (project?.nestedProjectPathsToIgnore?.length) {
+                const ignoreArgs = project.nestedProjectPathsToIgnore.map((nestedPath) => `--ignore=${nestedPath}`);
+                pytestArgs = [...pytestArgs, ...ignoreArgs];
+                traceInfo(
+                    `[test-by-project] Project ${project.projectName} ignoring nested project(s): ${ignoreArgs.join(
+                        ' ',
+                    )}`,
+                );
+            }
 
-    async runPytestDiscovery(
-        uri: Uri,
-        discoveryPipeName: string,
-        cSource: CancellationTokenSource,
-        executionFactory?: IPythonExecutionFactory,
-        interpreter?: PythonEnvironment,
-        token?: CancellationToken,
-    ): Promise<void> {
-        const relativePathToPytest = 'python_files';
-        const fullPluginPath = path.join(EXTENSION_ROOT_DIR, relativePathToPytest);
-        const settings = this.configSettings.getSettings(uri);
-        let { pytestArgs } = settings.testing;
-        const cwd = settings.testing.cwd && settings.testing.cwd.length > 0 ? settings.testing.cwd : uri.fsPath;
-
-        // check for symbolic path
-        const stats = await fs.promises.lstat(cwd);
-        const resolvedPath = await fs.promises.realpath(cwd);
-        let isSymbolicLink = false;
-        if (stats.isSymbolicLink()) {
-            isSymbolicLink = true;
-            traceWarn('The cwd is a symbolic link.');
-        } else if (resolvedPath !== cwd) {
-            traceWarn(
-                'The cwd resolves to a different path, checking if it has a symbolic link somewhere in its path.',
+            const commandArgs = ['-m', 'pytest', '-p', 'vscode_pytest', '--collect-only'].concat(pytestArgs);
+            traceVerbose(
+                `Running pytest discovery with command: ${commandArgs.join(' ')} for workspace ${uri.fsPath}.`,
             );
-            isSymbolicLink = await hasSymlinkParent(cwd);
-        }
-        if (isSymbolicLink) {
-            traceWarn("Symlink found, adding '--rootdir' to pytestArgs only if it doesn't already exist. cwd: ", cwd);
-            pytestArgs = addValueIfKeyNotExist(pytestArgs, '--rootdir', cwd);
-        }
-        // if user has provided `--rootdir` then use that, otherwise add `cwd`
-        // root dir is required so pytest can find the relative paths and for symlinks
-        addValueIfKeyNotExist(pytestArgs, '--rootdir', cwd);
-
-        // get and edit env vars
-        const mutableEnv = {
-            ...(await this.envVarsService?.getEnvironmentVariables(uri)),
-        };
-        // get python path from mutable env, it contains process.env as well
-        const pythonPathParts: string[] = mutableEnv.PYTHONPATH?.split(path.delimiter) ?? [];
-        const pythonPathCommand = [fullPluginPath, ...pythonPathParts].join(path.delimiter);
-        mutableEnv.PYTHONPATH = pythonPathCommand;
-        mutableEnv.TEST_RUN_PIPE = discoveryPipeName;
-        traceInfo(
-            `All environment variables set for pytest discovery, PYTHONPATH: ${JSON.stringify(mutableEnv.PYTHONPATH)}`,
-        );
-
-        // delete UUID following entire discovery finishing.
-        const execArgs = ['-m', 'pytest', '-p', 'vscode_pytest', '--collect-only'].concat(pytestArgs);
-        traceVerbose(`Running pytest discovery with command: ${execArgs.join(' ')} for workspace ${uri.fsPath}.`);
-
-        if (useEnvExtension()) {
-            const pythonEnv = await getEnvironment(uri);
-            if (pythonEnv) {
-                const deferredTillExecClose: Deferred<void> = createTestingDeferred();
+
+            // Configure subprocess environment
+            const mutableEnv = await configureDiscoveryEnv(this.envVarsService, uri, discoveryPipeName);
+
+            // Set PROJECT_ROOT_PATH for project-based testing (tells Python where to root the test tree)
+            if (project) {
+                mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
+            }
+
+            // Setup process handlers (shared by both execution paths)
+            const handlers = createProcessHandlers('pytest', uri, cwd, this.resultResolver, deferredTillExecClose, [5]);
+
+            // Execute using environment extension if available
+            if (useEnvExtension()) {
+                traceInfo(`Using environment extension for pytest discovery in workspace ${uri.fsPath}`);
+                const pythonEnv = project?.pythonEnvironment ?? (await getEnvironment(uri));
+                if (!pythonEnv) {
+                    traceError(
+                        `Python environment not found for workspace ${uri.fsPath}. Cannot proceed with test discovery.`,
+                    );
+                    deferredTillExecClose.resolve();
+                    return;
+                }
+                traceVerbose(`Using Python environment: ${JSON.stringify(pythonEnv)}`);
 
                 const proc = await runInBackground(pythonEnv, {
                     cwd,
-                    args: execArgs,
+                    args: commandArgs,
                     env: (mutableEnv as unknown) as { [key: string]: string },
                 });
-                token?.onCancellationRequested(() => {
-                    traceInfo(`Test discovery cancelled, killing pytest subprocess for workspace ${uri.fsPath}`);
-                    proc.kill();
-                    deferredTillExecClose.resolve();
-                    cSource.cancel();
-                });
-                proc.stdout.on('data', (data) => {
-                    const out = fixLogLinesNoTrailing(data.toString());
-                    traceInfo(out);
-                    this.outputChannel?.append(out);
-                });
-                proc.stderr.on('data', (data) => {
-                    const out = fixLogLinesNoTrailing(data.toString());
-                    traceError(out);
-                    this.outputChannel?.append(out);
+                traceInfo(`Started pytest discovery subprocess (environment extension) for workspace ${uri.fsPath}`);
+
+                // Wire up cancellation and process events
+                const envExtCancellationHandler = token?.onCancellationRequested(() => {
+                    cleanupOnCancellation('pytest', proc, deferredTillExecClose, discoveryPipeCancellation, uri);
                 });
+                if (envExtCancellationHandler) {
+                    disposables.push(envExtCancellationHandler);
+                }
+                proc.stdout.on('data', handlers.onStdout);
+                proc.stderr.on('data', handlers.onStderr);
                 proc.onExit((code, signal) => {
-                    this.outputChannel?.append(MESSAGE_ON_TESTING_OUTPUT_MOVE);
-                    if (code !== 0) {
-                        traceError(
-                            `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}`,
-                        );
-                        this.resultResolver?.resolveDiscovery(createDiscoveryErrorPayload(code, signal, cwd));
-                    }
-                    deferredTillExecClose.resolve();
+                    handlers.onExit(code, signal);
+                    handlers.onClose(code, signal);
                 });
+
                 await deferredTillExecClose.promise;
-            } else {
-                traceError(`Python Environment not found for: ${uri.fsPath}`);
+                traceInfo(`Pytest discovery completed for workspace ${uri.fsPath}`);
+                return;
             }
-            return;
-        }
 
-        const spawnOptions: SpawnOptions = {
-            cwd,
-            throwOnStdErr: true,
-            outputChannel: this.outputChannel,
-            env: mutableEnv,
-            token,
-        };
-
-        // Create the Python environment in which to execute the command.
-        const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
-            allowEnvironmentFetchExceptions: false,
-            resource: uri,
-            interpreter,
-        };
-        const execService = await executionFactory?.createActivatedEnvironment(creationOptions);
-
-        const execInfo = await execService?.getExecutablePath();
-        traceVerbose(`Executable path for pytest discovery: ${execInfo}.`);
-
-        const deferredTillExecClose: Deferred<void> = createTestingDeferred();
-
-        let resultProc: ChildProcess | undefined;
+            // Execute using execution factory (fallback path)
+            traceInfo(`Using execution factory for pytest discovery in workspace ${uri.fsPath}`);
+            const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
+                allowEnvironmentFetchExceptions: false,
+                resource: uri,
+                interpreter,
+            };
+            const execService = await executionFactory.createActivatedEnvironment(creationOptions);
+            if (!execService) {
+                traceError(
+                    `Failed to create execution service for workspace ${uri.fsPath}. Cannot proceed with test discovery.`,
+                );
+                deferredTillExecClose.resolve();
+                return;
+            }
+            const execInfo = await execService.getExecutablePath();
+            traceVerbose(`Using Python executable: ${execInfo} for workspace ${uri.fsPath}`);
 
-        token?.onCancellationRequested(() => {
-            traceInfo(`Test discovery cancelled, killing pytest subprocess for workspace ${uri.fsPath}`);
-            // if the resultProc exists just call kill on it which will handle resolving the ExecClose deferred, otherwise resolve the deferred here.
-            if (resultProc) {
-                resultProc?.kill();
-            } else {
+            // Check for cancellation before spawning process
+            if (token?.isCancellationRequested) {
+                traceInfo(`Pytest discovery cancelled before spawning process for workspace ${uri.fsPath}`);
                 deferredTillExecClose.resolve();
-                cSource.cancel();
+                return;
             }
-        });
-        const result = execService?.execObservable(execArgs, spawnOptions);
-        resultProc = result?.proc;
-
-        // Take all output from the subprocess and add it to the test output channel. This will be the pytest output.
-        // Displays output to user and ensure the subprocess doesn't run into buffer overflow.
-        // TODO: after a release, remove discovery output from the "Python Test Log" channel and send it to the "Python" channel instead.
-
-        result?.proc?.stdout?.on('data', (data) => {
-            const out = fixLogLinesNoTrailing(data.toString());
-            traceInfo(out);
-            spawnOptions?.outputChannel?.append(`${out}`);
-        });
-        result?.proc?.stderr?.on('data', (data) => {
-            const out = fixLogLinesNoTrailing(data.toString());
-            traceError(out);
-            spawnOptions?.outputChannel?.append(`${out}`);
-        });
-        result?.proc?.on('exit', (code, signal) => {
-            this.outputChannel?.append(MESSAGE_ON_TESTING_OUTPUT_MOVE);
-            if (code !== 0) {
-                traceError(
-                    `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}.`,
-                );
+
+            const spawnOptions: SpawnOptions = {
+                cwd,
+                throwOnStdErr: true,
+                env: mutableEnv,
+                token,
+            };
+
+            let resultProc: ChildProcess | undefined;
+
+            // Set up cancellation handler after all early return checks
+            const cancellationHandler = token?.onCancellationRequested(() => {
+                traceInfo(`Cancellation requested during pytest discovery for workspace ${uri.fsPath}`);
+                cleanupOnCancellation('pytest', resultProc, deferredTillExecClose, discoveryPipeCancellation, uri);
+            });
+            if (cancellationHandler) {
+                disposables.push(cancellationHandler);
             }
-        });
-        result?.proc?.on('close', (code, signal) => {
-            // pytest exits with code of 5 when 0 tests are found- this is not a failure for discovery.
-            if (code !== 0 && code !== 5) {
-                traceError(
-                    `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}. Creating and sending error discovery payload`,
-                );
-                this.resultResolver?.resolveDiscovery(createDiscoveryErrorPayload(code, signal, cwd));
+
+            try {
+                const result = execService.execObservable(commandArgs, spawnOptions);
+                resultProc = result?.proc;
+
+                if (!resultProc) {
+                    traceError(`Failed to spawn pytest discovery subprocess for workspace ${uri.fsPath}`);
+                    deferredTillExecClose.resolve();
+                    return;
+                }
+                traceInfo(`Started pytest discovery subprocess (execution factory) for workspace ${uri.fsPath}`);
+            } catch (error) {
+                traceError(`Error spawning pytest discovery subprocess for workspace ${uri.fsPath}: ${error}`);
+                deferredTillExecClose.resolve();
+                throw error;
             }
-            // due to the sync reading of the output.
-            deferredTillExecClose?.resolve();
-        });
-        await deferredTillExecClose.promise;
+            resultProc.stdout?.on('data', handlers.onStdout);
+            resultProc.stderr?.on('data', handlers.onStderr);
+            resultProc.on('exit', handlers.onExit);
+            resultProc.on('close', handlers.onClose);
+
+            traceVerbose(`Waiting for pytest discovery subprocess to complete for workspace ${uri.fsPath}`);
+            await deferredTillExecClose.promise;
+            traceInfo(`Pytest discovery completed for workspace ${uri.fsPath}`);
+        } catch (error) {
+            traceError(`Error during pytest discovery for workspace ${uri.fsPath}: ${error}`);
+            deferredTillExecClose.resolve();
+            throw error;
+        } finally {
+            // Dispose all cancellation handlers and event subscriptions
+            disposables.forEach((d) => d.dispose());
+            // Dispose the discovery pipe cancellation token
+            discoveryPipeCancellation.dispose();
+        }
     }
 }
diff --git a/src/client/testing/testController/pytest/pytestExecutionAdapter.ts b/src/client/testing/testController/pytest/pytestExecutionAdapter.ts
index 3a824f79ac63..102841c2e2dd 100644
--- a/src/client/testing/testController/pytest/pytestExecutionAdapter.ts
+++ b/src/client/testing/testController/pytest/pytestExecutionAdapter.ts
@@ -4,7 +4,7 @@
 import { CancellationTokenSource, DebugSessionOptions, TestRun, TestRunProfileKind, Uri } from 'vscode';
 import * as path from 'path';
 import { ChildProcess } from 'child_process';
-import { IConfigurationService, ITestOutputChannel } from '../../../common/types';
+import { IConfigurationService } from '../../../common/types';
 import { Deferred } from '../../../common/utils/async';
 import { traceError, traceInfo, traceVerbose } from '../../../logging';
 import { ExecutionTestPayload, ITestExecutionAdapter, ITestResultResolver } from '../common/types';
@@ -21,11 +21,11 @@ import * as utils from '../common/utils';
 import { IEnvironmentVariablesProvider } from '../../../common/variables/types';
 import { PythonEnvironment } from '../../../pythonEnvironments/info';
 import { getEnvironment, runInBackground, useEnvExtension } from '../../../envExt/api.internal';
+import { ProjectAdapter } from '../common/projectAdapter';
 
 export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
     constructor(
         public configSettings: IConfigurationService,
-        private readonly outputChannel: ITestOutputChannel,
         private readonly resultResolver?: ITestResultResolver,
         private readonly envVarsService?: IEnvironmentVariablesProvider,
     ) {}
@@ -33,11 +33,12 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
     async runTests(
         uri: Uri,
         testIds: string[],
-        profileKind?: TestRunProfileKind,
-        runInstance?: TestRun,
-        executionFactory?: IPythonExecutionFactory,
+        profileKind: boolean | TestRunProfileKind | undefined,
+        runInstance: TestRun,
+        executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         const deferredTillServerClose: Deferred<void> = utils.createTestingDeferred();
 
@@ -50,14 +51,14 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
             }
         };
         const cSource = new CancellationTokenSource();
-        runInstance?.token.onCancellationRequested(() => cSource.cancel());
+        runInstance.token.onCancellationRequested(() => cSource.cancel());
 
         const name = await utils.startRunResultNamedPipe(
             dataReceivedCallback, // callback to handle data received
             deferredTillServerClose, // deferred to resolve when server closes
             cSource.token, // token to cancel
         );
-        runInstance?.token.onCancellationRequested(() => {
+        runInstance.token.onCancellationRequested(() => {
             traceInfo(`Test run cancelled, resolving 'TillServerClose' deferred for ${uri.fsPath}.`);
         });
 
@@ -72,6 +73,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
                 executionFactory,
                 debugLauncher,
                 interpreter,
+                project,
             );
         } finally {
             await deferredTillServerClose.promise;
@@ -83,11 +85,12 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
         testIds: string[],
         resultNamedPipeName: string,
         serverCancel: CancellationTokenSource,
-        runInstance?: TestRun,
-        profileKind?: TestRunProfileKind,
-        executionFactory?: IPythonExecutionFactory,
+        runInstance: TestRun,
+        profileKind: boolean | TestRunProfileKind | undefined,
+        executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<ExecutionTestPayload> {
         const relativePathToPytest = 'python_files';
         const fullPluginPath = path.join(EXTENSION_ROOT_DIR, relativePathToPytest);
@@ -103,9 +106,17 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
         const pythonPathCommand = [fullPluginPath, ...pythonPathParts].join(path.delimiter);
         mutableEnv.PYTHONPATH = pythonPathCommand;
         mutableEnv.TEST_RUN_PIPE = resultNamedPipeName;
+
+        // Set PROJECT_ROOT_PATH for project-based testing (tells Python where to root the test tree)
+        if (project) {
+            mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
+            traceInfo(`[test-by-project] Setting PROJECT_ROOT_PATH=${project.projectUri.fsPath} for pytest execution`);
+        }
+
         if (profileKind && profileKind === TestRunProfileKind.Coverage) {
             mutableEnv.COVERAGE_ENABLED = 'True';
         }
+
         const debugBool = profileKind && profileKind === TestRunProfileKind.Debug;
 
         // Create the Python environment in which to execute the command.
@@ -115,7 +126,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
             interpreter,
         };
         // need to check what will happen in the exec service is NOT defined and is null
-        const execService = await executionFactory?.createActivatedEnvironment(creationOptions);
+        const execService = await executionFactory.createActivatedEnvironment(creationOptions);
 
         const execInfo = await execService?.getExecutablePath();
         traceVerbose(`Executable path for pytest execution: ${execInfo}.`);
@@ -138,27 +149,26 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
             const testIdsFileName = await utils.writeTestIdsFile(testIds);
             mutableEnv.RUN_TEST_IDS_PIPE = testIdsFileName;
             traceInfo(
-                `All environment variables set for pytest execution, PYTHONPATH: ${JSON.stringify(
-                    mutableEnv.PYTHONPATH,
-                )}`,
+                `Environment variables set for pytest execution: PYTHONPATH=${mutableEnv.PYTHONPATH}, TEST_RUN_PIPE=${mutableEnv.TEST_RUN_PIPE}, RUN_TEST_IDS_PIPE=${mutableEnv.RUN_TEST_IDS_PIPE}`,
             );
 
             const spawnOptions: SpawnOptions = {
                 cwd,
                 throwOnStdErr: true,
-                outputChannel: this.outputChannel,
                 env: mutableEnv,
-                token: runInstance?.token,
+                token: runInstance.token,
             };
 
             if (debugBool) {
                 const launchOptions: LaunchOptions = {
                     cwd,
                     args: testArgs,
-                    token: runInstance?.token,
+                    token: runInstance.token,
                     testProvider: PYTEST_PROVIDER,
                     runTestIdsPort: testIdsFileName,
                     pytestPort: resultNamedPipeName,
+                    // Pass project for project-based debugging (Python path and session name derived from this)
+                    project: project?.pythonProject,
                 };
                 const sessionOptions: DebugSessionOptions = {
                     testRun: runInstance,
@@ -172,7 +182,9 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
                     sessionOptions,
                 );
             } else if (useEnvExtension()) {
-                const pythonEnv = await getEnvironment(uri);
+                // For project-based execution, use the project's Python environment
+                // Otherwise, fall back to getting the environment from the URI
+                const pythonEnv = project?.pythonEnvironment ?? (await getEnvironment(uri));
                 if (pythonEnv) {
                     const deferredTillExecClose: Deferred<void> = utils.createTestingDeferred();
 
@@ -185,7 +197,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
                         args: runArgs,
                         env: (mutableEnv as unknown) as { [key: string]: string },
                     });
-                    runInstance?.token.onCancellationRequested(() => {
+                    runInstance.token.onCancellationRequested(() => {
                         traceInfo(`Test run cancelled, killing pytest subprocess for workspace ${uri.fsPath}`);
                         proc.kill();
                         deferredTillExecClose.resolve();
@@ -193,16 +205,13 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
                     });
                     proc.stdout.on('data', (data) => {
                         const out = utils.fixLogLinesNoTrailing(data.toString());
-                        runInstance?.appendOutput(out);
-                        this.outputChannel?.append(out);
+                        runInstance.appendOutput(out);
                     });
                     proc.stderr.on('data', (data) => {
                         const out = utils.fixLogLinesNoTrailing(data.toString());
-                        runInstance?.appendOutput(out);
-                        this.outputChannel?.append(out);
+                        runInstance.appendOutput(out);
                     });
                     proc.onExit((code, signal) => {
-                        this.outputChannel?.append(utils.MESSAGE_ON_TESTING_OUTPUT_MOVE);
                         if (code !== 0) {
                             traceError(
                                 `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}`,
@@ -225,7 +234,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
 
                 let resultProc: ChildProcess | undefined;
 
-                runInstance?.token.onCancellationRequested(() => {
+                runInstance.token.onCancellationRequested(() => {
                     traceInfo(`Test run cancelled, killing pytest subprocess for workspace ${uri.fsPath}`);
                     // if the resultProc exists just call kill on it which will handle resolving the ExecClose deferred, otherwise resolve the deferred here.
                     if (resultProc) {
@@ -240,19 +249,15 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
 
                 // Take all output from the subprocess and add it to the test output channel. This will be the pytest output.
                 // Displays output to user and ensure the subprocess doesn't run into buffer overflow.
-                // TODO: after a release, remove run output from the "Python Test Log" channel and send it to the "Test Result" channel instead.
                 result?.proc?.stdout?.on('data', (data) => {
                     const out = utils.fixLogLinesNoTrailing(data.toString());
-                    runInstance?.appendOutput(out);
-                    this.outputChannel?.append(out);
+                    runInstance.appendOutput(out);
                 });
                 result?.proc?.stderr?.on('data', (data) => {
                     const out = utils.fixLogLinesNoTrailing(data.toString());
-                    runInstance?.appendOutput(out);
-                    this.outputChannel?.append(out);
+                    runInstance.appendOutput(out);
                 });
                 result?.proc?.on('exit', (code, signal) => {
-                    this.outputChannel?.append(utils.MESSAGE_ON_TESTING_OUTPUT_MOVE);
                     if (code !== 0) {
                         traceError(
                             `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}`,
diff --git a/src/client/testing/testController/pytest/pytestHelpers.ts b/src/client/testing/testController/pytest/pytestHelpers.ts
new file mode 100644
index 000000000000..c6e748fb85a7
--- /dev/null
+++ b/src/client/testing/testController/pytest/pytestHelpers.ts
@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import * as path from 'path';
+import * as fs from 'fs';
+import { traceInfo, traceWarn } from '../../../logging';
+import { addValueIfKeyNotExist, hasSymlinkParent } from '../common/utils';
+
+/**
+ * Checks if the current working directory contains a symlink and ensures --rootdir is set in pytest args.
+ * This is required for pytest to correctly resolve relative paths in symlinked directories.
+ */
+export async function handleSymlinkAndRootDir(cwd: string, pytestArgs: string[]): Promise<string[]> {
+    const stats = await fs.promises.lstat(cwd);
+    const resolvedPath = await fs.promises.realpath(cwd);
+    let isSymbolicLink = false;
+    if (stats.isSymbolicLink()) {
+        isSymbolicLink = true;
+        traceWarn(`Working directory is a symbolic link: ${cwd} -> ${resolvedPath}`);
+    } else if (resolvedPath !== cwd) {
+        traceWarn(
+            `Working directory resolves to different path: ${cwd} -> ${resolvedPath}. Checking for symlinks in parent directories.`,
+        );
+        isSymbolicLink = await hasSymlinkParent(cwd);
+    }
+    if (isSymbolicLink) {
+        traceWarn(
+            `Symlink detected in path. Adding '--rootdir=${cwd}' to pytest args to ensure correct path resolution.`,
+        );
+        pytestArgs = addValueIfKeyNotExist(pytestArgs, '--rootdir', cwd);
+    }
+    // if user has provided `--rootdir` then use that, otherwise add `cwd`
+    // root dir is required so pytest can find the relative paths and for symlinks
+    pytestArgs = addValueIfKeyNotExist(pytestArgs, '--rootdir', cwd);
+    return pytestArgs;
+}
+
+/**
+ * Builds the environment variables required for pytest discovery.
+ * Sets PYTHONPATH to include the plugin path and TEST_RUN_PIPE for communication.
+ */
+export function buildPytestEnv(
+    envVars: { [key: string]: string | undefined } | undefined,
+    fullPluginPath: string,
+    discoveryPipeName: string,
+): { [key: string]: string | undefined } {
+    const mutableEnv = {
+        ...envVars,
+    };
+    // get python path from mutable env, it contains process.env as well
+    const pythonPathParts: string[] = mutableEnv.PYTHONPATH?.split(path.delimiter) ?? [];
+    const pythonPathCommand = [fullPluginPath, ...pythonPathParts].join(path.delimiter);
+    mutableEnv.PYTHONPATH = pythonPathCommand;
+    mutableEnv.TEST_RUN_PIPE = discoveryPipeName;
+    traceInfo(
+        `Environment variables set for pytest discovery: PYTHONPATH=${mutableEnv.PYTHONPATH}, TEST_RUN_PIPE=${mutableEnv.TEST_RUN_PIPE}`,
+    );
+    return mutableEnv;
+}
diff --git a/src/client/testing/testController/pytest/runner.ts b/src/client/testing/testController/pytest/runner.ts
deleted file mode 100644
index e62902e4060a..000000000000
--- a/src/client/testing/testController/pytest/runner.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-import { ITestsRunner } from '../common/types';
-
-export class PytestRunner implements ITestsRunner {
-    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-    constructor() {
-        // not used, but required for DI
-    }
-}
diff --git a/src/client/testing/testController/serviceRegistry.ts b/src/client/testing/testController/serviceRegistry.ts
index 783af6fc8bda..03bf883e8eb1 100644
--- a/src/client/testing/testController/serviceRegistry.ts
+++ b/src/client/testing/testController/serviceRegistry.ts
@@ -4,23 +4,19 @@
 import { IExtensionSingleActivationService } from '../../activation/types';
 import { IServiceManager } from '../../ioc/types';
 import { PYTEST_PROVIDER, UNITTEST_PROVIDER } from '../common/constants';
-import { ITestFrameworkController, ITestsRunner, ITestController } from './common/types';
+import { ITestFrameworkController, ITestController } from './common/types';
 import { PythonTestController } from './controller';
 import { PytestController } from './pytest/pytestController';
-import { PytestRunner } from './pytest/runner';
-import { UnittestRunner } from './unittest/runner';
 import { UnittestController } from './unittest/unittestController';
 
 export function registerTestControllerTypes(serviceManager: IServiceManager): void {
     serviceManager.addSingleton<ITestFrameworkController>(ITestFrameworkController, PytestController, PYTEST_PROVIDER);
-    serviceManager.addSingleton<ITestsRunner>(ITestsRunner, PytestRunner, PYTEST_PROVIDER);
 
     serviceManager.addSingleton<ITestFrameworkController>(
         ITestFrameworkController,
         UnittestController,
         UNITTEST_PROVIDER,
     );
-    serviceManager.addSingleton<ITestsRunner>(ITestsRunner, UnittestRunner, UNITTEST_PROVIDER);
     serviceManager.addSingleton<ITestController>(ITestController, PythonTestController);
     serviceManager.addBinding(ITestController, IExtensionSingleActivationService);
 }
diff --git a/src/client/testing/testController/unittest/runner.ts b/src/client/testing/testController/unittest/runner.ts
deleted file mode 100644
index 45a0bddaeb75..000000000000
--- a/src/client/testing/testController/unittest/runner.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-import { ITestsRunner } from '../common/types';
-
-export class UnittestRunner implements ITestsRunner {
-    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-    constructor() {
-        // not used, but required for DI
-    }
-}
diff --git a/src/client/testing/testController/unittest/testDiscoveryAdapter.ts b/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
index 7e478b25735a..558e01f3514d 100644
--- a/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
+++ b/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
@@ -1,232 +1,211 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import * as path from 'path';
-import { CancellationTokenSource, Uri } from 'vscode';
-import { CancellationToken } from 'vscode-jsonrpc';
+import { CancellationToken, Disposable, Uri } from 'vscode';
 import { ChildProcess } from 'child_process';
-import { IConfigurationService, ITestOutputChannel } from '../../../common/types';
+import { IConfigurationService } from '../../../common/types';
 import { EXTENSION_ROOT_DIR } from '../../../constants';
-import {
-    DiscoveredTestPayload,
-    ITestDiscoveryAdapter,
-    ITestResultResolver,
-    TestCommandOptions,
-    TestDiscoveryCommand,
-} from '../common/types';
-import { createDeferred } from '../../../common/utils/async';
-import { EnvironmentVariables, IEnvironmentVariablesProvider } from '../../../common/variables/types';
+import { ITestDiscoveryAdapter, ITestResultResolver } from '../common/types';
+import { IEnvironmentVariablesProvider } from '../../../common/variables/types';
 import {
     ExecutionFactoryCreateWithEnvironmentOptions,
-    ExecutionResult,
     IPythonExecutionFactory,
     SpawnOptions,
 } from '../../../common/process/types';
-import {
-    MESSAGE_ON_TESTING_OUTPUT_MOVE,
-    createDiscoveryErrorPayload,
-    fixLogLinesNoTrailing,
-    startDiscoveryNamedPipe,
-} from '../common/utils';
-import { traceError, traceInfo, traceLog, traceVerbose } from '../../../logging';
+import { traceError, traceInfo, traceVerbose } from '../../../logging';
 import { getEnvironment, runInBackground, useEnvExtension } from '../../../envExt/api.internal';
+import { PythonEnvironment } from '../../../pythonEnvironments/info';
+import { createTestingDeferred } from '../common/utils';
+import { buildDiscoveryCommand, buildUnittestEnv as configureSubprocessEnv } from './unittestHelpers';
+import { cleanupOnCancellation, createProcessHandlers, setupDiscoveryPipe } from '../common/discoveryHelpers';
+import { ProjectAdapter } from '../common/projectAdapter';
 
 /**
- * Wrapper class for unittest test discovery. This is where we call `runTestCommand`.
+ * Configures the subprocess environment for unittest discovery.
+ * @param envVarsService Service to retrieve environment variables
+ * @param uri Workspace URI
+ * @param discoveryPipeName Name of the discovery pipe to pass to the subprocess
+ * @returns Configured environment variables for the subprocess
+ */
+async function configureDiscoveryEnv(
+    envVarsService: IEnvironmentVariablesProvider | undefined,
+    uri: Uri,
+    discoveryPipeName: string,
+): Promise<NodeJS.ProcessEnv> {
+    const envVars = await envVarsService?.getEnvironmentVariables(uri);
+    const mutableEnv = configureSubprocessEnv(envVars, discoveryPipeName);
+    return mutableEnv;
+}
+
+/**
+ * Wrapper class for unittest test discovery.
  */
 export class UnittestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
     constructor(
         public configSettings: IConfigurationService,
-        private readonly outputChannel: ITestOutputChannel,
         private readonly resultResolver?: ITestResultResolver,
         private readonly envVarsService?: IEnvironmentVariablesProvider,
     ) {}
 
-    public async discoverTests(
+    async discoverTests(
         uri: Uri,
-        executionFactory?: IPythonExecutionFactory,
+        executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
+        interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
-        const settings = this.configSettings.getSettings(uri);
-        const { unittestArgs } = settings.testing;
-        const cwd = settings.testing.cwd && settings.testing.cwd.length > 0 ? settings.testing.cwd : uri.fsPath;
-
-        const cSource = new CancellationTokenSource();
-        // Create a deferred to return to the caller
-        const deferredReturn = createDeferred<void>();
-
-        token?.onCancellationRequested(() => {
-            traceInfo(`Test discovery cancelled.`);
-            cSource.cancel();
-            deferredReturn.resolve();
-        });
-
-        const name = await startDiscoveryNamedPipe((data: DiscoveredTestPayload) => {
-            if (!token?.isCancellationRequested) {
-                this.resultResolver?.resolveDiscovery(data);
-            }
-        }, cSource.token);
-
-        // set up env with the pipe name
-        let env: EnvironmentVariables | undefined = await this.envVarsService?.getEnvironmentVariables(uri);
-        if (env === undefined) {
-            env = {} as EnvironmentVariables;
+        // Setup discovery pipe and cancellation
+        const {
+            pipeName: discoveryPipeName,
+            cancellation: discoveryPipeCancellation,
+            tokenDisposable,
+        } = await setupDiscoveryPipe(this.resultResolver, token, uri);
+
+        // Setup process handlers deferred (used by both execution paths)
+        const deferredTillExecClose = createTestingDeferred();
+
+        // Collect all disposables for cleanup in finally block
+        const disposables: Disposable[] = [];
+        if (tokenDisposable) {
+            disposables.push(tokenDisposable);
         }
-        env.TEST_RUN_PIPE = name;
-
-        const command = buildDiscoveryCommand(unittestArgs);
-        const options: TestCommandOptions = {
-            workspaceFolder: uri,
-            command,
-            cwd,
-            outChannel: this.outputChannel,
-            token,
-        };
-
-        this.runDiscovery(uri, options, name, cwd, cSource, executionFactory).then(() => {
-            deferredReturn.resolve();
-        });
-
-        return deferredReturn.promise;
-    }
+        try {
+            // Build unittest command and arguments
+            const settings = this.configSettings.getSettings(uri);
+            const { unittestArgs } = settings.testing;
+            const cwd = settings.testing.cwd && settings.testing.cwd.length > 0 ? settings.testing.cwd : uri.fsPath;
+            const execArgs = buildDiscoveryCommand(unittestArgs, EXTENSION_ROOT_DIR);
+            traceVerbose(`Running unittest discovery with command: ${execArgs.join(' ')} for workspace ${uri.fsPath}.`);
+
+            // Configure subprocess environment
+            const mutableEnv = await configureDiscoveryEnv(this.envVarsService, uri, discoveryPipeName);
+
+            // Set PROJECT_ROOT_PATH for project-based testing (tells Python where to root the test tree)
+            if (project) {
+                mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
+                traceInfo(
+                    `[test-by-project] Setting PROJECT_ROOT_PATH=${project.projectUri.fsPath} for unittest discovery`,
+                );
+            }
 
-    async runDiscovery(
-        uri: Uri,
-        options: TestCommandOptions,
-        testRunPipeName: string,
-        cwd: string,
-        cSource: CancellationTokenSource,
-        executionFactory?: IPythonExecutionFactory,
-    ): Promise<void> {
-        // get and edit env vars
-        const mutableEnv = {
-            ...(await this.envVarsService?.getEnvironmentVariables(uri)),
-        };
-        mutableEnv.TEST_RUN_PIPE = testRunPipeName;
-        const args = [options.command.script].concat(options.command.args);
-
-        if (options.outChannel) {
-            options.outChannel.appendLine(`python ${args.join(' ')}`);
-        }
+            // Setup process handlers (shared by both execution paths)
+            const handlers = createProcessHandlers('unittest', uri, cwd, this.resultResolver, deferredTillExecClose);
 
-        if (useEnvExtension()) {
-            const pythonEnv = await getEnvironment(uri);
-            if (pythonEnv) {
-                const deferredTillExecClose = createDeferred();
+            // Execute using environment extension if available
+            if (useEnvExtension()) {
+                traceInfo(`Using environment extension for unittest discovery in workspace ${uri.fsPath}`);
+                const pythonEnv = project?.pythonEnvironment ?? (await getEnvironment(uri));
+                if (!pythonEnv) {
+                    traceError(
+                        `Python environment not found for workspace ${uri.fsPath}. Cannot proceed with test discovery.`,
+                    );
+                    deferredTillExecClose.resolve();
+                    return;
+                }
+                traceVerbose(`Using Python environment: ${JSON.stringify(pythonEnv)}`);
 
                 const proc = await runInBackground(pythonEnv, {
                     cwd,
-                    args,
+                    args: execArgs,
                     env: (mutableEnv as unknown) as { [key: string]: string },
                 });
-                options.token?.onCancellationRequested(() => {
-                    traceInfo(`Test discovery cancelled, killing unittest subprocess for workspace ${uri.fsPath}`);
-                    proc.kill();
-                    deferredTillExecClose.resolve();
-                    cSource.cancel();
-                });
-                proc.stdout.on('data', (data) => {
-                    const out = fixLogLinesNoTrailing(data.toString());
-                    traceInfo(out);
-                    this.outputChannel?.append(out);
-                });
-                proc.stderr.on('data', (data) => {
-                    const out = fixLogLinesNoTrailing(data.toString());
-                    traceError(out);
-                    this.outputChannel?.append(out);
+                traceInfo(`Started unittest discovery subprocess (environment extension) for workspace ${uri.fsPath}`);
+
+                // Wire up cancellation and process events
+                const envExtCancellationHandler = token?.onCancellationRequested(() => {
+                    cleanupOnCancellation('unittest', proc, deferredTillExecClose, discoveryPipeCancellation, uri);
                 });
+                if (envExtCancellationHandler) {
+                    disposables.push(envExtCancellationHandler);
+                }
+                proc.stdout.on('data', handlers.onStdout);
+                proc.stderr.on('data', handlers.onStderr);
                 proc.onExit((code, signal) => {
-                    this.outputChannel?.append(MESSAGE_ON_TESTING_OUTPUT_MOVE);
-                    if (code !== 0) {
-                        traceError(
-                            `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}`,
-                        );
-                    }
-                    deferredTillExecClose.resolve();
+                    handlers.onExit(code, signal);
+                    handlers.onClose(code, signal);
                 });
+
                 await deferredTillExecClose.promise;
-            } else {
-                traceError(`Python Environment not found for: ${uri.fsPath}`);
+                traceInfo(`Unittest discovery completed for workspace ${uri.fsPath}`);
+                return;
             }
-            return;
-        }
 
-        const spawnOptions: SpawnOptions = {
-            token: options.token,
-            cwd: options.cwd,
-            throwOnStdErr: true,
-            outputChannel: options.outChannel,
-            env: mutableEnv,
-        };
-
-        try {
-            traceLog(`Discovering unittest tests for workspace ${options.cwd} with arguments: ${args}\r\n`);
-            const deferredTillExecClose = createDeferred<ExecutionResult<string>>();
-
-            // Create the Python environment in which to execute the command.
+            // Execute using execution factory (fallback path)
+            traceInfo(`Using execution factory for unittest discovery in workspace ${uri.fsPath}`);
             const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
                 allowEnvironmentFetchExceptions: false,
-                resource: options.workspaceFolder,
+                resource: uri,
+                interpreter,
+            };
+            const execService = await executionFactory.createActivatedEnvironment(creationOptions);
+            if (!execService) {
+                traceError(
+                    `Failed to create execution service for workspace ${uri.fsPath}. Cannot proceed with test discovery.`,
+                );
+                deferredTillExecClose.resolve();
+                return;
+            }
+            const execInfo = await execService.getExecutablePath();
+            traceVerbose(`Using Python executable: ${execInfo} for workspace ${uri.fsPath}`);
+
+            // Check for cancellation before spawning process
+            if (token?.isCancellationRequested) {
+                traceInfo(`Unittest discovery cancelled before spawning process for workspace ${uri.fsPath}`);
+                deferredTillExecClose.resolve();
+                return;
+            }
+
+            const spawnOptions: SpawnOptions = {
+                cwd,
+                throwOnStdErr: true,
+                env: mutableEnv,
+                token,
             };
-            const execService = await executionFactory?.createActivatedEnvironment(creationOptions);
-            const execInfo = await execService?.getExecutablePath();
-            traceVerbose(`Executable path for unittest discovery: ${execInfo}.`);
 
             let resultProc: ChildProcess | undefined;
-            options.token?.onCancellationRequested(() => {
-                traceInfo(`Test discovery cancelled, killing unittest subprocess for workspace ${uri.fsPath}`);
-                // if the resultProc exists just call kill on it which will handle resolving the ExecClose deferred, otherwise resolve the deferred here.
-                if (resultProc) {
-                    resultProc?.kill();
-                } else {
-                    deferredTillExecClose.resolve();
-                    cSource.cancel();
-                }
-            });
-            const result = execService?.execObservable(args, spawnOptions);
-            resultProc = result?.proc;
-
-            // Displays output to user and ensure the subprocess doesn't run into buffer overflow.
-            // TODO: after a release, remove discovery output from the "Python Test Log" channel and send it to the "Python" channel instead.
-            // TODO: after a release, remove run output from the "Python Test Log" channel and send it to the "Test Result" channel instead.
-            result?.proc?.stdout?.on('data', (data) => {
-                const out = fixLogLinesNoTrailing(data.toString());
-                spawnOptions?.outputChannel?.append(`${out}`);
-                traceInfo(out);
-            });
-            result?.proc?.stderr?.on('data', (data) => {
-                const out = fixLogLinesNoTrailing(data.toString());
-                spawnOptions?.outputChannel?.append(`${out}`);
-                traceError(out);
+
+            // Set up cancellation handler after all early return checks
+            const cancellationHandler = token?.onCancellationRequested(() => {
+                traceInfo(`Cancellation requested during unittest discovery for workspace ${uri.fsPath}`);
+                cleanupOnCancellation('unittest', resultProc, deferredTillExecClose, discoveryPipeCancellation, uri);
             });
+            if (cancellationHandler) {
+                disposables.push(cancellationHandler);
+            }
 
-            result?.proc?.on('exit', (code, signal) => {
-                // if the child has testIds then this is a run request
-                spawnOptions?.outputChannel?.append(MESSAGE_ON_TESTING_OUTPUT_MOVE);
+            try {
+                const result = execService.execObservable(execArgs, spawnOptions);
+                resultProc = result?.proc;
 
-                if (code !== 0) {
-                    // This occurs when we are running discovery
-                    traceError(
-                        `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${options.cwd}. Creating and sending error discovery payload \n`,
-                    );
-                    traceError(
-                        `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}. Creating and sending error discovery payload`,
-                    );
-                    this.resultResolver?.resolveDiscovery(createDiscoveryErrorPayload(code, signal, cwd));
+                if (!resultProc) {
+                    traceError(`Failed to spawn unittest discovery subprocess for workspace ${uri.fsPath}`);
+                    deferredTillExecClose.resolve();
+                    return;
                 }
+                traceInfo(`Started unittest discovery subprocess (execution factory) for workspace ${uri.fsPath}`);
+            } catch (error) {
+                traceError(`Error spawning unittest discovery subprocess for workspace ${uri.fsPath}: ${error}`);
                 deferredTillExecClose.resolve();
-            });
+                throw error;
+            }
+            resultProc.stdout?.on('data', handlers.onStdout);
+            resultProc.stderr?.on('data', handlers.onStderr);
+            resultProc.on('exit', handlers.onExit);
+            resultProc.on('close', handlers.onClose);
+
+            traceVerbose(`Waiting for unittest discovery subprocess to complete for workspace ${uri.fsPath}`);
             await deferredTillExecClose.promise;
-        } catch (ex) {
-            traceError(`Error while server attempting to run unittest command for workspace ${uri.fsPath}: ${ex}`);
+            traceInfo(`Unittest discovery completed for workspace ${uri.fsPath}`);
+        } catch (error) {
+            traceError(`Error during unittest discovery for workspace ${uri.fsPath}: ${error}`);
+            deferredTillExecClose.resolve();
+            throw error;
+        } finally {
+            traceVerbose(`Cleaning up unittest discovery resources for workspace ${uri.fsPath}`);
+            // Dispose all cancellation handlers and event subscriptions
+            disposables.forEach((d) => d.dispose());
+            // Dispose the discovery pipe cancellation token
+            discoveryPipeCancellation.dispose();
         }
     }
 }
-function buildDiscoveryCommand(args: string[]): TestDiscoveryCommand {
-    const discoveryScript = path.join(EXTENSION_ROOT_DIR, 'python_files', 'unittestadapter', 'discovery.py');
-
-    return {
-        script: discoveryScript,
-        args: ['--udiscovery', ...args],
-    };
-}
diff --git a/src/client/testing/testController/unittest/testExecutionAdapter.ts b/src/client/testing/testController/unittest/testExecutionAdapter.ts
index e46e8c436583..c7d21b768c5b 100644
--- a/src/client/testing/testController/unittest/testExecutionAdapter.ts
+++ b/src/client/testing/testController/unittest/testExecutionAdapter.ts
@@ -4,7 +4,7 @@
 import * as path from 'path';
 import { CancellationTokenSource, DebugSessionOptions, TestRun, TestRunProfileKind, Uri } from 'vscode';
 import { ChildProcess } from 'child_process';
-import { IConfigurationService, ITestOutputChannel } from '../../../common/types';
+import { IConfigurationService } from '../../../common/types';
 import { Deferred, createDeferred } from '../../../common/utils/async';
 import { EXTENSION_ROOT_DIR } from '../../../constants';
 import {
@@ -15,7 +15,7 @@ import {
     TestExecutionCommand,
 } from '../common/types';
 import { traceError, traceInfo, traceLog, traceVerbose } from '../../../logging';
-import { MESSAGE_ON_TESTING_OUTPUT_MOVE, fixLogLinesNoTrailing } from '../common/utils';
+import { fixLogLinesNoTrailing } from '../common/utils';
 import { EnvironmentVariables, IEnvironmentVariablesProvider } from '../../../common/variables/types';
 import {
     ExecutionFactoryCreateWithEnvironmentOptions,
@@ -27,6 +27,8 @@ import { ITestDebugLauncher, LaunchOptions } from '../../common/types';
 import { UNITTEST_PROVIDER } from '../../common/constants';
 import * as utils from '../common/utils';
 import { getEnvironment, runInBackground, useEnvExtension } from '../../../envExt/api.internal';
+import { PythonEnvironment } from '../../../pythonEnvironments/info';
+import { ProjectAdapter } from '../common/projectAdapter';
 
 /**
  * Wrapper Class for unittest test execution. This is where we call `runTestCommand`?
@@ -35,7 +37,6 @@ import { getEnvironment, runInBackground, useEnvExtension } from '../../../envEx
 export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
     constructor(
         public configSettings: IConfigurationService,
-        private readonly outputChannel: ITestOutputChannel,
         private readonly resultResolver?: ITestResultResolver,
         private readonly envVarsService?: IEnvironmentVariablesProvider,
     ) {}
@@ -43,10 +44,12 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
     public async runTests(
         uri: Uri,
         testIds: string[],
-        profileKind?: TestRunProfileKind,
-        runInstance?: TestRun,
-        executionFactory?: IPythonExecutionFactory,
+        profileKind: boolean | TestRunProfileKind | undefined,
+        runInstance: TestRun,
+        executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
+        _interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         // deferredTillServerClose awaits named pipe server close
         const deferredTillServerClose: Deferred<void> = utils.createTestingDeferred();
@@ -60,13 +63,13 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
             }
         };
         const cSource = new CancellationTokenSource();
-        runInstance?.token.onCancellationRequested(() => cSource.cancel());
+        runInstance.token.onCancellationRequested(() => cSource.cancel());
         const name = await utils.startRunResultNamedPipe(
             dataReceivedCallback, // callback to handle data received
             deferredTillServerClose, // deferred to resolve when server closes
             cSource.token, // token to cancel
         );
-        runInstance?.token.onCancellationRequested(() => {
+        runInstance.token.onCancellationRequested(() => {
             console.log(`Test run cancelled, resolving 'till TillAllServerClose' deferred for ${uri.fsPath}.`);
             // if canceled, stop listening for results
             deferredTillServerClose.resolve();
@@ -81,6 +84,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                 profileKind,
                 executionFactory,
                 debugLauncher,
+                project,
             );
         } catch (error) {
             traceError(`Error in running unittest tests: ${error}`);
@@ -94,10 +98,11 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
         testIds: string[],
         resultNamedPipeName: string,
         serverCancel: CancellationTokenSource,
-        runInstance?: TestRun,
-        profileKind?: TestRunProfileKind,
-        executionFactory?: IPythonExecutionFactory,
+        runInstance: TestRun,
+        profileKind: boolean | TestRunProfileKind | undefined,
+        executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
+        project?: ProjectAdapter,
     ): Promise<ExecutionTestPayload> {
         const settings = this.configSettings.getSettings(uri);
         const { unittestArgs } = settings.testing;
@@ -112,6 +117,15 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
         const pythonPathCommand = [cwd, ...pythonPathParts].join(path.delimiter);
         mutableEnv.PYTHONPATH = pythonPathCommand;
         mutableEnv.TEST_RUN_PIPE = resultNamedPipeName;
+
+        // Set PROJECT_ROOT_PATH for project-based testing (tells Python where to root the test tree)
+        if (project) {
+            mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
+            traceInfo(
+                `[test-by-project] Setting PROJECT_ROOT_PATH=${project.projectUri.fsPath} for unittest execution`,
+            );
+        }
+
         if (profileKind && profileKind === TestRunProfileKind.Coverage) {
             mutableEnv.COVERAGE_ENABLED = cwd;
         }
@@ -120,10 +134,9 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
             workspaceFolder: uri,
             command,
             cwd,
-            profileKind,
+            profileKind: typeof profileKind === 'boolean' ? undefined : profileKind,
             testIds,
-            outChannel: this.outputChannel,
-            token: runInstance?.token,
+            token: runInstance.token,
         };
         traceLog(`Running UNITTEST execution for the following test ids: ${testIds}`);
 
@@ -140,7 +153,6 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
             token: options.token,
             cwd: options.cwd,
             throwOnStdErr: true,
-            outputChannel: options.outChannel,
             env: mutableEnv,
         };
         // Create the Python environment in which to execute the command.
@@ -148,7 +160,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
             allowEnvironmentFetchExceptions: false,
             resource: options.workspaceFolder,
         };
-        const execService = await executionFactory?.createActivatedEnvironment(creationOptions);
+        const execService = await executionFactory.createActivatedEnvironment(creationOptions);
 
         const execInfo = await execService?.getExecutablePath();
         traceVerbose(`Executable path for unittest execution: ${execInfo}.`);
@@ -168,6 +180,8 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                     testProvider: UNITTEST_PROVIDER,
                     runTestIdsPort: testIdsFileName,
                     pytestPort: resultNamedPipeName, // change this from pytest
+                    // Pass project for project-based debugging (Python path and session name derived from this)
+                    project: project?.pythonProject,
                 };
                 const sessionOptions: DebugSessionOptions = {
                     testRun: runInstance,
@@ -186,7 +200,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                     sessionOptions,
                 );
             } else if (useEnvExtension()) {
-                const pythonEnv = await getEnvironment(uri);
+                const pythonEnv = project?.pythonEnvironment ?? (await getEnvironment(uri));
                 if (pythonEnv) {
                     traceInfo(`Running unittest with arguments: ${args.join(' ')} for workspace ${uri.fsPath} \r\n`);
                     const deferredTillExecClose = createDeferred();
@@ -196,7 +210,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                         args,
                         env: (mutableEnv as unknown) as { [key: string]: string },
                     });
-                    runInstance?.token.onCancellationRequested(() => {
+                    runInstance.token.onCancellationRequested(() => {
                         traceInfo(`Test run cancelled, killing unittest subprocess for workspace ${uri.fsPath}`);
                         proc.kill();
                         deferredTillExecClose.resolve();
@@ -204,16 +218,13 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                     });
                     proc.stdout.on('data', (data) => {
                         const out = utils.fixLogLinesNoTrailing(data.toString());
-                        runInstance?.appendOutput(out);
-                        this.outputChannel?.append(out);
+                        runInstance.appendOutput(out);
                     });
                     proc.stderr.on('data', (data) => {
                         const out = utils.fixLogLinesNoTrailing(data.toString());
-                        runInstance?.appendOutput(out);
-                        this.outputChannel?.append(out);
+                        runInstance.appendOutput(out);
                     });
                     proc.onExit((code, signal) => {
-                        this.outputChannel?.append(utils.MESSAGE_ON_TESTING_OUTPUT_MOVE);
                         if (code !== 0) {
                             traceError(
                                 `Subprocess exited unsuccessfully with exit code ${code} and signal ${signal} on workspace ${uri.fsPath}`,
@@ -234,7 +245,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
 
                 let resultProc: ChildProcess | undefined;
 
-                runInstance?.token.onCancellationRequested(() => {
+                runInstance.token.onCancellationRequested(() => {
                     traceInfo(`Test run cancelled, killing unittest subprocess for workspace ${cwd}.`);
                     // if the resultProc exists just call kill on it which will handle resolving the ExecClose deferred, otherwise resolve the deferred here.
                     if (resultProc) {
@@ -249,23 +260,18 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                 resultProc = result?.proc;
 
                 // Displays output to user and ensure the subprocess doesn't run into buffer overflow.
-                // TODO: after a release, remove discovery output from the "Python Test Log" channel and send it to the "Python" channel instead.
-                // TODO: after a release, remove run output from the "Python Test Log" channel and send it to the "Test Result" channel instead.
 
                 result?.proc?.stdout?.on('data', (data) => {
                     const out = fixLogLinesNoTrailing(data.toString());
-                    runInstance?.appendOutput(`${out}`);
-                    spawnOptions?.outputChannel?.append(out);
+                    runInstance.appendOutput(`${out}`);
                 });
                 result?.proc?.stderr?.on('data', (data) => {
                     const out = fixLogLinesNoTrailing(data.toString());
-                    runInstance?.appendOutput(`${out}`);
-                    spawnOptions?.outputChannel?.append(out);
+                    runInstance.appendOutput(`${out}`);
                 });
 
                 result?.proc?.on('exit', (code, signal) => {
                     // if the child has testIds then this is a run request
-                    spawnOptions?.outputChannel?.append(MESSAGE_ON_TESTING_OUTPUT_MOVE);
                     if (code !== 0 && testIds) {
                         // This occurs when we are running the test and there is an error which occurs.
 
diff --git a/src/client/testing/testController/unittest/unittestHelpers.ts b/src/client/testing/testController/unittest/unittestHelpers.ts
new file mode 100644
index 000000000000..249a78dda7b7
--- /dev/null
+++ b/src/client/testing/testController/unittest/unittestHelpers.ts
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+import * as path from 'path';
+import { traceInfo } from '../../../logging';
+
+/**
+ * Builds the environment variables required for unittest discovery.
+ * Sets TEST_RUN_PIPE for communication.
+ */
+export function buildUnittestEnv(
+    envVars: { [key: string]: string | undefined } | undefined,
+    discoveryPipeName: string,
+): { [key: string]: string | undefined } {
+    const mutableEnv = {
+        ...envVars,
+    };
+    mutableEnv.TEST_RUN_PIPE = discoveryPipeName;
+    traceInfo(`Environment variables set for unittest discovery: TEST_RUN_PIPE=${mutableEnv.TEST_RUN_PIPE}`);
+    return mutableEnv;
+}
+
+/**
+ * Builds the unittest discovery command.
+ */
+export function buildDiscoveryCommand(args: string[], extensionRootDir: string): string[] {
+    const discoveryScript = path.join(extensionRootDir, 'python_files', 'unittestadapter', 'discovery.py');
+    return [discoveryScript, '--udiscovery', ...args];
+}
diff --git a/src/client/testing/testController/workspaceTestAdapter.ts b/src/client/testing/testController/workspaceTestAdapter.ts
index a73acdaba5f0..f17687732f57 100644
--- a/src/client/testing/testController/workspaceTestAdapter.ts
+++ b/src/client/testing/testController/workspaceTestAdapter.ts
@@ -15,6 +15,7 @@ import { IPythonExecutionFactory } from '../../common/process/types';
 import { ITestDebugLauncher } from '../common/types';
 import { buildErrorNodeOptions } from './common/utils';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
+import { ProjectAdapter } from './common/projectAdapter';
 
 /**
  * This class exposes a test-provider-agnostic way of discovering tests.
@@ -42,11 +43,12 @@ export class WorkspaceTestAdapter {
         testController: TestController,
         runInstance: TestRun,
         includes: TestItem[],
+        executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         profileKind?: boolean | TestRunProfileKind,
-        executionFactory?: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         if (this.executing) {
             traceError('Test execution already in progress, not starting a new one.');
@@ -73,20 +75,19 @@ export class WorkspaceTestAdapter {
                 }
             });
             const testCaseIds = Array.from(testCaseIdsSet);
-            // ** execution factory only defined for new rewrite way
-            if (executionFactory !== undefined) {
-                await this.executionAdapter.runTests(
-                    this.workspaceUri,
-                    testCaseIds,
-                    profileKind,
-                    runInstance,
-                    executionFactory,
-                    debugLauncher,
-                    interpreter,
-                );
-            } else {
-                await this.executionAdapter.runTests(this.workspaceUri, testCaseIds, profileKind);
+            if (executionFactory === undefined) {
+                throw new Error('Execution factory is required for test execution');
             }
+            await this.executionAdapter.runTests(
+                this.workspaceUri,
+                testCaseIds,
+                profileKind,
+                runInstance,
+                executionFactory,
+                debugLauncher,
+                interpreter,
+                project,
+            );
             deferred.resolve();
         } catch (ex) {
             // handle token and telemetry here
@@ -116,8 +117,8 @@ export class WorkspaceTestAdapter {
 
     public async discoverTests(
         testController: TestController,
+        executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
-        executionFactory?: IPythonExecutionFactory,
         interpreter?: PythonEnvironment,
     ): Promise<void> {
         sendTelemetryEvent(EventName.UNITTEST_DISCOVERING, undefined, { tool: this.testProvider });
@@ -132,12 +133,10 @@ export class WorkspaceTestAdapter {
         this.discovering = deferred;
 
         try {
-            // ** execution factory only defined for new rewrite way
-            if (executionFactory !== undefined) {
-                await this.discoveryAdapter.discoverTests(this.workspaceUri, executionFactory, token, interpreter);
-            } else {
-                await this.discoveryAdapter.discoverTests(this.workspaceUri);
+            if (executionFactory === undefined) {
+                throw new Error('Execution factory is required for test discovery');
             }
+            await this.discoveryAdapter.discoverTests(this.workspaceUri, executionFactory, token, interpreter);
             deferred.resolve();
         } catch (ex) {
             sendTelemetryEvent(EventName.UNITTEST_DISCOVERY_DONE, undefined, { tool: this.testProvider, failed: true });
diff --git a/src/client/testing/utils.ts b/src/client/testing/utils.ts
new file mode 100644
index 000000000000..c1027d4a8dc1
--- /dev/null
+++ b/src/client/testing/utils.ts
@@ -0,0 +1,49 @@
+import { TestItem, env } from 'vscode';
+import { traceLog } from '../logging';
+
+export async function writeTestIdToClipboard(testItem: TestItem): Promise<void> {
+    if (testItem && typeof testItem.id === 'string') {
+        if (testItem.id.includes('\\') && testItem.id.indexOf('::') === -1) {
+            // Convert the id to a module.class.method format as this is a unittest
+            const moduleClassMethod = idToModuleClassMethod(testItem.id);
+            if (moduleClassMethod) {
+                await env.clipboard.writeText(moduleClassMethod);
+                traceLog('Testing: Copied test id to clipboard, id: ' + moduleClassMethod);
+                return;
+            }
+        }
+        // Otherwise use the id as is for pytest
+        await clipboardWriteText(testItem.id);
+        traceLog('Testing: Copied test id to clipboard, id: ' + testItem.id);
+    }
+}
+
+export function idToModuleClassMethod(id: string): string | undefined {
+    // Split by backslash
+    const parts = id.split('\\');
+    if (parts.length === 1) {
+        // Only one part, likely a parent folder or file
+        return parts[0];
+    }
+    if (parts.length === 2) {
+        // Two parts: filePath and className
+        const [filePath, className] = parts.slice(-2);
+        const fileName = filePath.split(/[\\/]/).pop();
+        if (!fileName) {
+            return undefined;
+        }
+        const module = fileName.replace(/\.py$/, '');
+        return `${module}.${className}`;
+    }
+    // Three or more parts: filePath, className, methodName
+    const [filePath, className, methodName] = parts.slice(-3);
+    const fileName = filePath.split(/[\\/]/).pop();
+    if (!fileName) {
+        return undefined;
+    }
+    const module = fileName.replace(/\.py$/, '');
+    return `${module}.${className}.${methodName}`;
+}
+export function clipboardWriteText(text: string): Thenable<void> {
+    return env.clipboard.writeText(text);
+}
diff --git a/src/test/activation/extensionSurvey.unit.test.ts b/src/test/activation/extensionSurvey.unit.test.ts
index 8e191ec82810..a89797bfebef 100644
--- a/src/test/activation/extensionSurvey.unit.test.ts
+++ b/src/test/activation/extensionSurvey.unit.test.ts
@@ -127,21 +127,38 @@ suite('Extension survey prompt - shouldShowBanner()', () => {
         }
         random.verifyAll();
     });
-    test('Returns false if telemetry.disableFeedback is enabled', async () => {
+    test('Returns true if telemetry.feedback.enabled is enabled', async () => {
         disableSurveyForTime.setup((d) => d.value).returns(() => false);
         doNotShowAgain.setup((d) => d.value).returns(() => false);
 
         const telemetryConfig = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
         workspaceService.setup((w) => w.getConfiguration('telemetry')).returns(() => telemetryConfig.object);
         telemetryConfig
-            .setup((t) => t.get(TypeMoq.It.isValue('disableFeedback'), TypeMoq.It.isValue(false)))
+            .setup((t) => t.get(TypeMoq.It.isValue('feedback.enabled'), TypeMoq.It.isValue(true)))
             .returns(() => true);
 
         const result = extensionSurveyPrompt.shouldShowBanner();
 
-        expect(result).to.equal(false, 'Banner should not be shown when telemetry.disableFeedback is true');
+        expect(result).to.equal(true, 'Banner should be shown when telemetry.feedback.enabled is true');
         workspaceService.verify((w) => w.getConfiguration('telemetry'), TypeMoq.Times.once());
-        telemetryConfig.verify((t) => t.get('disableFeedback', false), TypeMoq.Times.once());
+        telemetryConfig.verify((t) => t.get('feedback.enabled', true), TypeMoq.Times.once());
+    });
+
+    test('Returns false if telemetry.feedback.enabled is disabled', async () => {
+        disableSurveyForTime.setup((d) => d.value).returns(() => false);
+        doNotShowAgain.setup((d) => d.value).returns(() => false);
+
+        const telemetryConfig = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
+        workspaceService.setup((w) => w.getConfiguration('telemetry')).returns(() => telemetryConfig.object);
+        telemetryConfig
+            .setup((t) => t.get(TypeMoq.It.isValue('feedback.enabled'), TypeMoq.It.isValue(true)))
+            .returns(() => false);
+
+        const result = extensionSurveyPrompt.shouldShowBanner();
+
+        expect(result).to.equal(false, 'Banner should not be shown when feedback.enabled is false');
+        workspaceService.verify((w) => w.getConfiguration('telemetry'), TypeMoq.Times.once());
+        telemetryConfig.verify((t) => t.get('feedback.enabled', true), TypeMoq.Times.once());
     });
 
     test('Returns true if user is in the random sampling', async () => {
diff --git a/src/test/activation/jedi/jediAnalysisOptions.unit.test.ts b/src/test/activation/jedi/jediAnalysisOptions.unit.test.ts
index 3456a6252722..66cb9e0ae604 100644
--- a/src/test/activation/jedi/jediAnalysisOptions.unit.test.ts
+++ b/src/test/activation/jedi/jediAnalysisOptions.unit.test.ts
@@ -74,6 +74,7 @@ suite('Jedi LSP - analysis Options', () => {
         expect(result.initializationOptions.hover.disable.keyword.all).to.deep.equal(true);
         expect(result.initializationOptions.workspace.extraPaths).to.deep.equal([]);
         expect(result.initializationOptions.workspace.symbols.maxSymbols).to.deep.equal(0);
+        expect(result.initializationOptions.semantic_tokens.enable).to.deep.equal(true);
     });
 
     test('With interpreter path', async () => {
diff --git a/src/test/api.functional.test.ts b/src/test/api.functional.test.ts
index 1149dcb7da9d..03016956dbef 100644
--- a/src/test/api.functional.test.ts
+++ b/src/test/api.functional.test.ts
@@ -19,7 +19,11 @@ import { ServiceManager } from '../client/ioc/serviceManager';
 import { IServiceContainer, IServiceManager } from '../client/ioc/types';
 import { IDiscoveryAPI } from '../client/pythonEnvironments/base/locator';
 import * as pythonDebugger from '../client/debugger/pythonDebugger';
-import { JupyterExtensionPythonEnvironments, JupyterPythonEnvironmentApi } from '../client/jupyter/jupyterIntegration';
+import {
+    JupyterExtensionIntegration,
+    JupyterExtensionPythonEnvironments,
+    JupyterPythonEnvironmentApi,
+} from '../client/jupyter/jupyterIntegration';
 import { EventEmitter, Uri } from 'vscode';
 
 suite('Extension API', () => {
@@ -50,6 +54,9 @@ suite('Extension API', () => {
         when(serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider)).thenReturn(
             instance(environmentVariablesProvider),
         );
+        when(serviceContainer.get<JupyterExtensionIntegration>(JupyterExtensionIntegration)).thenReturn(
+            instance(mock<JupyterExtensionIntegration>()),
+        );
         when(serviceContainer.get<IInterpreterService>(IInterpreterService)).thenReturn(instance(interpreterService));
         const onDidChangePythonEnvironment = new EventEmitter<Uri>();
         const jupyterApi: JupyterPythonEnvironmentApi = {
diff --git a/src/test/chat/utils.unit.test.ts b/src/test/chat/utils.unit.test.ts
new file mode 100644
index 000000000000..8d45c1ac118f
--- /dev/null
+++ b/src/test/chat/utils.unit.test.ts
@@ -0,0 +1,248 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Uri, WorkspaceFolder } from 'vscode';
+import { resolveFilePath } from '../../client/chat/utils';
+import * as workspaceApis from '../../client/common/vscodeApis/workspaceApis';
+
+suite('Chat Utils - resolveFilePath()', () => {
+    let getWorkspaceFoldersStub: sinon.SinonStub;
+
+    setup(() => {
+        getWorkspaceFoldersStub = sinon.stub(workspaceApis, 'getWorkspaceFolders');
+        getWorkspaceFoldersStub.returns([]);
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    suite('When filepath is undefined or empty', () => {
+        test('Should return first workspace folder URI when workspace folders exist', () => {
+            const expectedUri = Uri.file('/test/workspace');
+            const mockFolder: WorkspaceFolder = {
+                uri: expectedUri,
+                name: 'test',
+                index: 0,
+            };
+            getWorkspaceFoldersStub.returns([mockFolder]);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result?.toString()).to.equal(expectedUri.toString());
+        });
+
+        test('Should return first folder when multiple workspace folders exist', () => {
+            const firstUri = Uri.file('/first/workspace');
+            const secondUri = Uri.file('/second/workspace');
+            const mockFolders: WorkspaceFolder[] = [
+                { uri: firstUri, name: 'first', index: 0 },
+                { uri: secondUri, name: 'second', index: 1 },
+            ];
+            getWorkspaceFoldersStub.returns(mockFolders);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result?.toString()).to.equal(firstUri.toString());
+        });
+
+        test('Should return undefined when no workspace folders exist', () => {
+            getWorkspaceFoldersStub.returns(undefined);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result).to.be.undefined;
+        });
+
+        test('Should return undefined when workspace folders is empty array', () => {
+            getWorkspaceFoldersStub.returns([]);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result).to.be.undefined;
+        });
+
+        test('Should return undefined for empty string when no workspace folders', () => {
+            getWorkspaceFoldersStub.returns(undefined);
+
+            const result = resolveFilePath('');
+
+            expect(result).to.be.undefined;
+        });
+    });
+
+    suite('Windows file paths', () => {
+        test('Should handle Windows path with lowercase drive letter', () => {
+            const filepath = 'c:\\GIT\\tests\\simple-python-app';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            // Uri.file normalizes drive letters to lowercase
+            expect(result?.fsPath.toLowerCase()).to.include('git');
+        });
+
+        test('Should handle Windows path with uppercase drive letter', () => {
+            const filepath = 'C:\\Users\\test\\project';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            expect(result?.fsPath.toLowerCase()).to.include('users');
+        });
+
+        test('Should handle Windows path with forward slashes', () => {
+            const filepath = 'C:/Users/test/project';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+
+    suite('Unix file paths', () => {
+        test('Should handle Unix absolute path', () => {
+            const filepath = '/home/user/projects/myapp';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            expect(result?.path).to.include('/home/user/projects/myapp');
+        });
+
+        test('Should handle Unix root path', () => {
+            const filepath = '/';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+
+    suite('Relative paths', () => {
+        test('Should handle relative path with dot prefix', () => {
+            const filepath = './src/main.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle relative path without prefix', () => {
+            const filepath = 'src/main.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle parent directory reference', () => {
+            const filepath = '../other-project/file.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+
+    suite('URI schemes', () => {
+        test('Should handle file:// URI scheme', () => {
+            const filepath = 'file:///home/user/test.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            expect(result?.path).to.include('/home/user/test.py');
+        });
+
+        test('Should handle vscode-notebook:// URI scheme', () => {
+            const filepath = 'vscode-notebook://jupyter/notebook.ipynb';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('vscode-notebook');
+        });
+
+        test('Should handle untitled: URI scheme without double slash as file path', () => {
+            const filepath = 'untitled:Untitled-1';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            // untitled: doesn't have ://, so it will be treated as a file path
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle https:// URI scheme', () => {
+            const filepath = 'https://example.com/path';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('https');
+        });
+
+        test('Should handle vscode-vfs:// URI scheme', () => {
+            const filepath = 'vscode-vfs://github/microsoft/vscode/file.ts';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('vscode-vfs');
+        });
+    });
+
+    suite('Edge cases', () => {
+        test('Should handle path with spaces', () => {
+            const filepath = '/home/user/my project/file.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle path with special characters', () => {
+            const filepath = '/home/user/project-name_v2/file.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should not treat Windows drive letter colon as URI scheme', () => {
+            // Windows path should not be confused with a URI scheme
+            const filepath = 'd:\\projects\\test';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should not treat single colon as URI scheme', () => {
+            // A path with a colon but not :// should be treated as a file
+            const filepath = 'c:somepath';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+});
diff --git a/src/test/common.ts b/src/test/common.ts
index b6e352b9a3e8..886323e815a5 100644
--- a/src/test/common.ts
+++ b/src/test/common.ts
@@ -62,7 +62,7 @@ export async function updateSetting(
     configTarget: ConfigurationTarget,
 ) {
     const vscode = require('vscode') as typeof import('vscode');
-    const settings = vscode.workspace.getConfiguration('python', { uri: resource, languageId: 'python' } || null);
+    const settings = vscode.workspace.getConfiguration('python', { uri: resource, languageId: 'python' });
     const currentValue = settings.inspect(setting);
     if (
         currentValue !== undefined &&
diff --git a/src/test/common/application/commands/reportIssueCommand.unit.test.ts b/src/test/common/application/commands/reportIssueCommand.unit.test.ts
index b1884fa83c21..175a43d14007 100644
--- a/src/test/common/application/commands/reportIssueCommand.unit.test.ts
+++ b/src/test/common/application/commands/reportIssueCommand.unit.test.ts
@@ -126,17 +126,17 @@ suite('Report Issue Command', () => {
         );
         const expectedData = fs.readFileSync(userDataTemplatePath, 'utf8');
 
-        const args: [string, { extensionId: string; issueBody: string; data: string }] = capture<
+        const args: [string, { extensionId: string; issueBody: string; extensionData: string }] = capture<
             AllCommands,
-            { extensionId: string; issueBody: string; data: string }
+            { extensionId: string; issueBody: string; extensionData: string }
         >(cmdManager.executeCommand).last();
 
         verify(cmdManager.registerCommand(Commands.ReportIssue, anything(), anything())).once();
         verify(cmdManager.executeCommand('workbench.action.openIssueReporter', anything())).once();
         expect(args[0]).to.be.equal('workbench.action.openIssueReporter');
-        const { issueBody, data } = args[1];
+        const { issueBody, extensionData } = args[1];
         expect(issueBody).to.be.equal(expectedIssueBody);
-        expect(data).to.be.equal(expectedData);
+        expect(extensionData).to.be.equal(expectedData);
     });
 
     test('Test if issue body is filled when only including settings which are explicitly set', async () => {
@@ -167,16 +167,16 @@ suite('Report Issue Command', () => {
         );
         const expectedData = fs.readFileSync(userDataTemplatePath, 'utf8');
 
-        const args: [string, { extensionId: string; issueBody: string; data: string }] = capture<
+        const args: [string, { extensionId: string; issueBody: string; extensionData: string }] = capture<
             AllCommands,
-            { extensionId: string; issueBody: string; data: string }
+            { extensionId: string; issueBody: string; extensionData: string }
         >(cmdManager.executeCommand).last();
 
         verify(cmdManager.executeCommand('workbench.action.openIssueReporter', anything())).once();
         expect(args[0]).to.be.equal('workbench.action.openIssueReporter');
-        const { issueBody, data } = args[1];
+        const { issueBody, extensionData } = args[1];
         expect(issueBody).to.be.equal(expectedIssueBody);
-        expect(data).to.be.equal(expectedData);
+        expect(extensionData).to.be.equal(expectedData);
     });
     test('Should send telemetry event when run Report Issue Command', async () => {
         const sendTelemetryStub = sinon.stub(Telemetry, 'sendTelemetryEvent');
diff --git a/src/test/common/configSettings/configSettings.pythonPath.unit.test.ts b/src/test/common/configSettings/configSettings.pythonPath.unit.test.ts
index 29082bb5854f..8a2a90b288a3 100644
--- a/src/test/common/configSettings/configSettings.pythonPath.unit.test.ts
+++ b/src/test/common/configSettings/configSettings.pythonPath.unit.test.ts
@@ -17,6 +17,7 @@ import { PythonEnvironment } from '../../../client/pythonEnvironments/info';
 import * as EnvFileTelemetry from '../../../client/telemetry/envFileTelemetry';
 import { MockAutoSelectionService } from '../../mocks/autoSelector';
 import { untildify } from '../../../client/common/helpers';
+import { MockExtensions } from '../../mocks/extensions';
 
 suite('Python Settings - pythonPath', () => {
     class CustomPythonSettings extends PythonSettings {
@@ -64,6 +65,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         configSettings.update(pythonSettings.object);
 
@@ -78,6 +80,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         configSettings.update(pythonSettings.object);
 
@@ -93,6 +96,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
 
         configSettings.update(pythonSettings.object);
@@ -110,6 +114,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         configSettings.update(pythonSettings.object);
 
@@ -126,6 +131,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         configSettings.update(pythonSettings.object);
 
@@ -145,6 +151,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         configSettings.update(pythonSettings.object);
 
@@ -166,6 +173,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         configSettings.update(pythonSettings.object);
 
@@ -184,6 +192,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         interpreterPathService.setup((i) => i.get(typemoq.It.isAny())).returns(() => 'custom');
         pythonSettings.setup((p) => p.get(typemoq.It.isValue('defaultInterpreterPath'))).returns(() => 'python');
@@ -204,6 +213,7 @@ suite('Python Settings - pythonPath', () => {
             workspaceService.object,
             interpreterPathService.object,
             undefined,
+            new MockExtensions(),
         );
         interpreterPathService.setup((i) => i.get(resource)).returns(() => 'python');
         configSettings.update(pythonSettings.object);
diff --git a/src/test/common/configSettings/configSettings.unit.test.ts b/src/test/common/configSettings/configSettings.unit.test.ts
index 43fbf17e970e..65afc782d7bb 100644
--- a/src/test/common/configSettings/configSettings.unit.test.ts
+++ b/src/test/common/configSettings/configSettings.unit.test.ts
@@ -27,6 +27,7 @@ import { ITestingSettings } from '../../../client/testing/configuration/types';
 import { MockAutoSelectionService } from '../../mocks/autoSelector';
 import { MockMemento } from '../../mocks/mementos';
 import { untildify } from '../../../client/common/helpers';
+import { MockExtensions } from '../../mocks/extensions';
 
 suite('Python Settings', async () => {
     class CustomPythonSettings extends PythonSettings {
@@ -40,6 +41,7 @@ suite('Python Settings', async () => {
     let config: TypeMoq.IMock<WorkspaceConfiguration>;
     let expected: CustomPythonSettings;
     let settings: CustomPythonSettings;
+    let extensions: MockExtensions;
     setup(() => {
         sinon.stub(EnvFileTelemetry, 'sendSettingTelemetry').returns();
         config = TypeMoq.Mock.ofType<WorkspaceConfiguration>(undefined, TypeMoq.MockBehavior.Loose);
@@ -47,6 +49,7 @@ suite('Python Settings', async () => {
         const workspaceService = new WorkspaceService();
         const workspaceMemento = new MockMemento();
         const globalMemento = new MockMemento();
+        extensions = new MockExtensions();
         const persistentStateFactory = new PersistentStateFactory(globalMemento, workspaceMemento);
         expected = new CustomPythonSettings(
             undefined,
@@ -55,7 +58,8 @@ suite('Python Settings', async () => {
             new InterpreterPathService(persistentStateFactory, workspaceService, [], {
                 remoteName: undefined,
             } as IApplicationEnvironment),
-            undefined,
+            { defaultLSType: LanguageServerType.Jedi },
+            extensions,
         );
         settings = new CustomPythonSettings(
             undefined,
@@ -64,7 +68,8 @@ suite('Python Settings', async () => {
             new InterpreterPathService(persistentStateFactory, workspaceService, [], {
                 remoteName: undefined,
             } as IApplicationEnvironment),
-            undefined,
+            { defaultLSType: LanguageServerType.Jedi },
+            extensions,
         );
         expected.defaultInterpreterPath = 'python';
     });
@@ -226,7 +231,7 @@ suite('Python Settings', async () => {
         const values = [
             { ls: LanguageServerType.Jedi, expected: LanguageServerType.Jedi, default: false },
             { ls: LanguageServerType.JediLSP, expected: LanguageServerType.Jedi, default: false },
-            { ls: LanguageServerType.Microsoft, expected: LanguageServerType.None, default: true },
+            { ls: LanguageServerType.Microsoft, expected: LanguageServerType.Jedi, default: true },
             { ls: LanguageServerType.Node, expected: LanguageServerType.Node, default: false },
             { ls: LanguageServerType.None, expected: LanguageServerType.None, default: false },
         ];
@@ -235,7 +240,48 @@ suite('Python Settings', async () => {
             testLanguageServer(v.ls, v.expected, v.default);
         });
 
-        testLanguageServer('invalid' as LanguageServerType, LanguageServerType.None, true);
+        testLanguageServer('invalid' as LanguageServerType, LanguageServerType.Jedi, true);
+    });
+
+    function testPyreflySettings(pyreflyInstalled: boolean, pyreflyDisabled: boolean, languageServerDisabled: boolean) {
+        test(`pyrefly ${pyreflyInstalled ? 'installed' : 'not installed'} and ${
+            pyreflyDisabled ? 'disabled' : 'enabled'
+        }`, () => {
+            if (pyreflyInstalled) {
+                extensions.extensionIdsToFind = ['meta.pyrefly'];
+            } else {
+                extensions.extensionIdsToFind = [];
+            }
+            config.setup((c) => c.get<boolean>('pyrefly.disableLanguageServices')).returns(() => pyreflyDisabled);
+
+            config
+                .setup((c) => c.get<string>('languageServer'))
+                .returns(() => undefined)
+                .verifiable(TypeMoq.Times.once());
+
+            settings.update(config.object);
+
+            if (languageServerDisabled) {
+                expect(settings.languageServer).to.equal(LanguageServerType.None);
+            } else {
+                expect(settings.languageServer).not.to.equal(LanguageServerType.None);
+            }
+            expect(settings.languageServerIsDefault).to.equal(true);
+            config.verifyAll();
+        });
+    }
+
+    suite('pyrefly languageServer settings', async () => {
+        const values = [
+            { pyreflyInstalled: true, pyreflyDisabled: false, languageServerDisabled: true },
+            { pyreflyInstalled: true, pyreflyDisabled: true, languageServerDisabled: false },
+            { pyreflyInstalled: false, pyreflyDisabled: true, languageServerDisabled: false },
+            { pyreflyInstalled: false, pyreflyDisabled: false, languageServerDisabled: false },
+        ];
+
+        values.forEach((v) => {
+            testPyreflySettings(v.pyreflyInstalled, v.pyreflyDisabled, v.languageServerDisabled);
+        });
     });
 
     function testExperiments(enabled: boolean) {
diff --git a/src/test/common/platform/fs-temp.unit.test.ts b/src/test/common/platform/fs-temp.unit.test.ts
index bfc8284b33d6..29b4e5f42b12 100644
--- a/src/test/common/platform/fs-temp.unit.test.ts
+++ b/src/test/common/platform/fs-temp.unit.test.ts
@@ -7,11 +7,14 @@ import { TemporaryFileSystem } from '../../../client/common/platform/fs-temp';
 
 interface IDeps {
     // tmp module
-    file(
-        config: { postfix?: string; mode?: number },
-
-        callback?: (err: any, path: string, fd: number, cleanupCallback: () => void) => void,
-    ): void;
+    fileSync(config: {
+        postfix?: string;
+        mode?: number;
+    }): {
+        name: string;
+        fd: number;
+        removeCallback(): void;
+    };
 }
 
 suite('FileSystem - temp files', () => {
@@ -28,7 +31,7 @@ suite('FileSystem - temp files', () => {
     suite('createFile', () => {
         test(`fails if the raw call fails`, async () => {
             const failure = new Error('oops');
-            deps.setup((d) => d.file({ postfix: '.tmp', mode: undefined }, TypeMoq.It.isAny()))
+            deps.setup((d) => d.fileSync({ postfix: '.tmp', mode: undefined }))
                 // fail with an arbitrary error
                 .throws(failure);
 
@@ -40,7 +43,7 @@ suite('FileSystem - temp files', () => {
 
         test(`fails if the raw call "returns" an error`, async () => {
             const failure = new Error('oops');
-            deps.setup((d) => d.file({ postfix: '.tmp', mode: undefined }, TypeMoq.It.isAny())).callback((_cfg, cb) =>
+            deps.setup((d) => d.fileSync({ postfix: '.tmp', mode: undefined })).callback((_cfg, cb) =>
                 cb(failure, '...', -1, () => {}),
             );
 
diff --git a/src/test/common/process/logger.unit.test.ts b/src/test/common/process/logger.unit.test.ts
index f1421ea58b85..366a7056e89e 100644
--- a/src/test/common/process/logger.unit.test.ts
+++ b/src/test/common/process/logger.unit.test.ts
@@ -109,32 +109,55 @@ suite('ProcessLogger suite', () => {
 
     test('Logger replaces the path/to/home with ~ in the command path where the home path IS NOT at the beginning of the path', async () => {
         const options = { cwd: path.join('debug', 'path') };
-        logger.logProcess(path.join('net', untildify('~'), 'test'), ['--foo', '--bar'], options);
+        const untildifyStr = untildify('~');
+
+        let p1 = path.join('net', untildifyStr, 'test');
+        if (p1.startsWith('.')) {
+            if (getOSType() === OSType.Windows) {
+                p1 = p1.replace(/^\.\\+/, '');
+            } else {
+                p1 = p1.replace(/^\.\\/, '');
+            }
+        }
+        logger.logProcess(p1, ['--foo', '--bar'], options);
 
-        sinon.assert.calledWithExactly(traceLogStub, `> ${path.join('net', '~', 'test')} --foo --bar`);
+        const path1 = path.join('.', 'net', '~', 'test');
+        sinon.assert.calledWithExactly(traceLogStub, `> ${path1} --foo --bar`);
         sinon.assert.calledWithExactly(traceLogStub, `cwd: ${options.cwd}`);
     });
 
     test('Logger replaces the path/to/home with ~ in the command path where the home path IS NOT at the beginning of the path but another arg contains other ref to home folder', async () => {
         const options = { cwd: path.join('debug', 'path') };
-        logger.logProcess(
-            path.join('net', untildify('~'), 'test'),
-            ['--foo', path.join(untildify('~'), 'boo')],
-            options,
-        );
+        let p1 = path.join('net', untildify('~'), 'test');
+        if (p1.startsWith('.')) {
+            if (getOSType() === OSType.Windows) {
+                p1 = p1.replace(/^\.\\+/, '');
+            } else {
+                p1 = p1.replace(/^\.\\/, '');
+            }
+        }
+        logger.logProcess(p1, ['--foo', path.join(untildify('~'), 'boo')], options);
 
         sinon.assert.calledWithExactly(
             traceLogStub,
-            `> ${path.join('net', '~', 'test')} --foo ${path.join('~', 'boo')}`,
+            `> ${path.join('.', 'net', '~', 'test')} --foo ${path.join('~', 'boo')}`,
         );
         sinon.assert.calledWithExactly(traceLogStub, `cwd: ${options.cwd}`);
     });
 
     test('Logger replaces the path/to/home with ~ in the command path where the home path IS NOT at the beginning of the path between doble quotes', async () => {
         const options = { cwd: path.join('debug', 'path') };
-        logger.logProcess(`"${path.join('net', untildify('~'), 'test')}" "--foo" "--bar"`, undefined, options);
+        let p1 = path.join('net', untildify('~'), 'test');
+        if (p1.startsWith('.')) {
+            if (getOSType() === OSType.Windows) {
+                p1 = p1.replace(/^\.\\+/, '');
+            } else {
+                p1 = p1.replace(/^\.\\/, '');
+            }
+        }
+        logger.logProcess(`"${p1}" "--foo" "--bar"`, undefined, options);
 
-        sinon.assert.calledWithExactly(traceLogStub, `> "${path.join('net', '~', 'test')}" "--foo" "--bar"`);
+        sinon.assert.calledWithExactly(traceLogStub, `> "${path.join('.', 'net', '~', 'test')}" "--foo" "--bar"`);
         sinon.assert.calledWithExactly(traceLogStub, `cwd: ${options.cwd}`);
     });
 
diff --git a/src/test/common/terminals/activation.unit.test.ts b/src/test/common/terminals/activation.unit.test.ts
index 49ada1c06b11..d87d33ea03e6 100644
--- a/src/test/common/terminals/activation.unit.test.ts
+++ b/src/test/common/terminals/activation.unit.test.ts
@@ -3,6 +3,7 @@
 
 'use strict';
 import { expect } from 'chai';
+import * as sinon from 'sinon';
 import { anything, instance, mock, verify, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
 import { Terminal, Uri } from 'vscode';
@@ -15,6 +16,7 @@ import { IDisposable } from '../../../client/common/types';
 import { TerminalAutoActivation } from '../../../client/terminals/activation';
 import { ITerminalAutoActivation } from '../../../client/terminals/types';
 import { noop } from '../../core';
+import * as extapi from '../../../client/envExt/api.internal';
 
 suite('Terminal Auto Activation', () => {
     let activator: ITerminalActivator;
@@ -25,6 +27,7 @@ suite('Terminal Auto Activation', () => {
     let terminal: Terminal;
 
     setup(() => {
+        sinon.stub(extapi, 'shouldEnvExtHandleActivation').returns(false);
         terminal = ({
             dispose: noop,
             hide: noop,
@@ -46,6 +49,9 @@ suite('Terminal Auto Activation', () => {
             instance(activeResourceService),
         );
     });
+    teardown(() => {
+        sinon.restore();
+    });
 
     test('New Terminals should be activated', async () => {
         type EventHandler = (e: Terminal) => void;
diff --git a/src/test/common/terminals/activator/index.unit.test.ts b/src/test/common/terminals/activator/index.unit.test.ts
index 6a50901bc99d..34d1cf8f1bcd 100644
--- a/src/test/common/terminals/activator/index.unit.test.ts
+++ b/src/test/common/terminals/activator/index.unit.test.ts
@@ -6,7 +6,7 @@
 import { assert } from 'chai';
 import * as sinon from 'sinon';
 import * as TypeMoq from 'typemoq';
-import { Terminal } from 'vscode';
+import { Terminal, Uri } from 'vscode';
 import { TerminalActivator } from '../../../../client/common/terminal/activator';
 import {
     ITerminalActivationHandler,
@@ -20,6 +20,8 @@ import {
     ITerminalSettings,
 } from '../../../../client/common/types';
 import * as extapi from '../../../../client/envExt/api.internal';
+import * as workspaceApis from '../../../../client/common/vscodeApis/workspaceApis';
+import * as extensionsApi from '../../../../client/common/vscodeApis/extensionsApi';
 
 suite('Terminal Activator', () => {
     let activator: TerminalActivator;
@@ -29,9 +31,12 @@ suite('Terminal Activator', () => {
     let terminalSettings: TypeMoq.IMock<ITerminalSettings>;
     let experimentService: TypeMoq.IMock<IExperimentService>;
     let useEnvExtensionStub: sinon.SinonStub;
+    let shouldEnvExtHandleActivationStub: sinon.SinonStub;
     setup(() => {
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
         useEnvExtensionStub.returns(false);
+        shouldEnvExtHandleActivationStub = sinon.stub(extapi, 'shouldEnvExtHandleActivation');
+        shouldEnvExtHandleActivationStub.returns(false);
 
         baseActivator = TypeMoq.Mock.ofType<ITerminalActivator>();
         terminalSettings = TypeMoq.Mock.ofType<ITerminalSettings>();
@@ -113,4 +118,92 @@ suite('Terminal Activator', () => {
     test('Terminal is not activated if auto-activate setting is set to true but terminal is hidden', () =>
         testActivationAndHandlers(false, true, true));
     test('Terminal is not activated and handlers are invoked', () => testActivationAndHandlers(false, false));
+
+    test('Terminal is not activated from Python extension when Env extension should handle activation', async () => {
+        shouldEnvExtHandleActivationStub.returns(true);
+        terminalSettings.setup((b) => b.activateEnvironment).returns(() => true);
+        baseActivator
+            .setup((b) => b.activateEnvironmentInTerminal(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(true))
+            .verifiable(TypeMoq.Times.never());
+
+        const terminal = TypeMoq.Mock.ofType<Terminal>();
+        const activated = await activator.activateEnvironmentInTerminal(terminal.object, {
+            preserveFocus: true,
+        });
+
+        assert.strictEqual(activated, false);
+        baseActivator.verifyAll();
+    });
+});
+
+suite('shouldEnvExtHandleActivation', () => {
+    let getExtensionStub: sinon.SinonStub;
+    let getConfigurationStub: sinon.SinonStub;
+    let getWorkspaceFoldersStub: sinon.SinonStub;
+
+    setup(() => {
+        getExtensionStub = sinon.stub(extensionsApi, 'getExtension');
+        getConfigurationStub = sinon.stub(workspaceApis, 'getConfiguration');
+        getWorkspaceFoldersStub = sinon.stub(workspaceApis, 'getWorkspaceFolders');
+        getWorkspaceFoldersStub.returns(undefined);
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('Returns false when envs extension is not installed', () => {
+        getExtensionStub.returns(undefined);
+        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
+    });
+
+    test('Returns true when envs extension is installed and setting is not explicitly set', () => {
+        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
+        getConfigurationStub.returns({
+            inspect: () => ({ globalValue: undefined, workspaceValue: undefined }),
+        });
+        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), true);
+    });
+
+    test('Returns false when envs extension is installed but globalValue is false', () => {
+        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
+        getConfigurationStub.returns({
+            inspect: () => ({ globalValue: false, workspaceValue: undefined }),
+        });
+        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
+    });
+
+    test('Returns false when envs extension is installed but workspaceValue is false', () => {
+        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
+        getConfigurationStub.returns({
+            inspect: () => ({ globalValue: undefined, workspaceValue: false }),
+        });
+        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
+    });
+
+    test('Returns true when envs extension is installed and setting is explicitly true', () => {
+        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
+        getConfigurationStub.returns({
+            inspect: () => ({ globalValue: true, workspaceValue: undefined }),
+        });
+        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), true);
+    });
+
+    test('Returns false when a workspace folder has workspaceFolderValue set to false', () => {
+        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
+        const folderUri = Uri.parse('file:///workspace/folder1');
+        getWorkspaceFoldersStub.returns([{ uri: folderUri, name: 'folder1', index: 0 }]);
+        getConfigurationStub.callsFake((_section: string, scope?: Uri) => {
+            if (scope) {
+                return {
+                    inspect: () => ({ workspaceFolderValue: false }),
+                };
+            }
+            return {
+                inspect: () => ({ globalValue: undefined, workspaceValue: undefined }),
+            };
+        });
+        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
+    });
 });
diff --git a/src/test/common/terminals/service.unit.test.ts b/src/test/common/terminals/service.unit.test.ts
index 63a1cd544940..3a6d54c9390b 100644
--- a/src/test/common/terminals/service.unit.test.ts
+++ b/src/test/common/terminals/service.unit.test.ts
@@ -14,8 +14,9 @@ import {
     Uri,
     Terminal as VSCodeTerminal,
     WorkspaceConfiguration,
+    TerminalDataWriteEvent,
 } from 'vscode';
-import { ITerminalManager, IWorkspaceService } from '../../../client/common/application/types';
+import { IApplicationShell, ITerminalManager, IWorkspaceService } from '../../../client/common/application/types';
 import { EXTENSION_ROOT_DIR } from '../../../client/common/constants';
 import { IPlatformService } from '../../../client/common/platform/types';
 import { TerminalService } from '../../../client/common/terminal/service';
@@ -56,6 +57,9 @@ suite('Terminal Service', () => {
     let useEnvExtensionStub: sinon.SinonStub;
     let interpreterService: TypeMoq.IMock<IInterpreterService>;
     let options: TypeMoq.IMock<TerminalCreationOptions>;
+    let applicationShell: TypeMoq.IMock<IApplicationShell>;
+    let onDidWriteTerminalDataEmitter: EventEmitter<TerminalDataWriteEvent>;
+    let onDidChangeTerminalStateEmitter: EventEmitter<VSCodeTerminal>;
 
     setup(() => {
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
@@ -118,6 +122,17 @@ suite('Terminal Service', () => {
         mockServiceContainer.setup((c) => c.get(ITerminalActivator)).returns(() => terminalActivator.object);
         mockServiceContainer.setup((c) => c.get(ITerminalAutoActivation)).returns(() => terminalAutoActivator.object);
         mockServiceContainer.setup((c) => c.get(IInterpreterService)).returns(() => interpreterService.object);
+
+        applicationShell = TypeMoq.Mock.ofType<IApplicationShell>();
+        onDidWriteTerminalDataEmitter = new EventEmitter<TerminalDataWriteEvent>();
+        applicationShell.setup((a) => a.onDidWriteTerminalData).returns(() => onDidWriteTerminalDataEmitter.event);
+        mockServiceContainer.setup((c) => c.get(IApplicationShell)).returns(() => applicationShell.object);
+
+        onDidChangeTerminalStateEmitter = new EventEmitter<VSCodeTerminal>();
+        terminalManager
+            .setup((t) => t.onDidChangeTerminalState(TypeMoq.It.isAny()))
+            .returns((handler) => onDidChangeTerminalStateEmitter.event(handler));
+
         getConfigurationStub = sinon.stub(workspaceApis, 'getConfiguration');
         isWindowsStub = sinon.stub(platform, 'isWindows');
         pythonConfig = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
@@ -230,8 +245,10 @@ suite('Terminal Service', () => {
         terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
         terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
 
-        service.ensureTerminal();
-        service.executeCommand(textToSend, true);
+        await service.ensureTerminal();
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidWriteTerminalDataEmitter.fire({ terminal: terminal.object, data: '>>> ' });
+        await executePromise;
 
         terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.exactly(1));
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
@@ -251,14 +268,16 @@ suite('Terminal Service', () => {
         terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
         terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
 
-        service.ensureTerminal();
-        service.executeCommand(textToSend, true);
+        await service.ensureTerminal();
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidWriteTerminalDataEmitter.fire({ terminal: terminal.object, data: '>>> ' });
+        await executePromise;
 
         terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.exactly(1));
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
     });
 
-    test('Ensure sendText is NOT called when Python shell integration and terminal shell integration are both enabled - Mac, Linux && Python < 3.13', async () => {
+    test('Ensure sendText is called when Python shell integration and terminal shell integration are both enabled - Mac, Linux && Python < 3.13', async () => {
         isWindowsStub.returns(false);
         pythonConfig
             .setup((p) => p.get('terminal.shellIntegration.enabled'))
@@ -273,11 +292,13 @@ suite('Terminal Service', () => {
         terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
         terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
 
-        service.ensureTerminal();
-        service.executeCommand(textToSend, true);
+        await service.ensureTerminal();
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidWriteTerminalDataEmitter.fire({ terminal: terminal.object, data: '>>> ' });
+        await executePromise;
 
         terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.exactly(1));
-        terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.never());
+        terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
     });
 
     test('Ensure sendText is called when Python shell integration and terminal shell integration are both enabled - Mac, Linux && Python >= 3.13', async () => {
@@ -305,7 +326,9 @@ suite('Terminal Service', () => {
         terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
 
         await service.ensureTerminal();
-        await service.executeCommand(textToSend, true);
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidWriteTerminalDataEmitter.fire({ terminal: terminal.object, data: '>>> ' });
+        await executePromise;
 
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.once());
     });
@@ -325,13 +348,39 @@ suite('Terminal Service', () => {
         terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
         terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
 
-        service.ensureTerminal();
-        service.executeCommand(textToSend, true);
+        await service.ensureTerminal();
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidWriteTerminalDataEmitter.fire({ terminal: terminal.object, data: '>>> ' });
+        await executePromise;
 
         terminal.verify((t) => t.show(TypeMoq.It.isValue(true)), TypeMoq.Times.exactly(1));
         terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
     });
 
+    test('Ensure REPL ready when onDidChangeTerminalState fires with python shell', async () => {
+        pythonConfig
+            .setup((p) => p.get('terminal.shellIntegration.enabled'))
+            .returns(() => false)
+            .verifiable(TypeMoq.Times.once());
+
+        terminalHelper
+            .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(() => Promise.resolve(undefined));
+        service = new TerminalService(mockServiceContainer.object);
+        const textToSend = 'Some Text';
+        terminalHelper.setup((h) => h.identifyTerminalShell(TypeMoq.It.isAny())).returns(() => TerminalShellType.bash);
+
+        terminal.setup((t) => t.state).returns(() => ({ isInteractedWith: true, shell: 'python' }));
+        terminalManager.setup((t) => t.createTerminal(TypeMoq.It.isAny())).returns(() => terminal.object);
+
+        await service.ensureTerminal();
+        const executePromise = service.executeCommand(textToSend, true);
+        onDidChangeTerminalStateEmitter.fire(terminal.object);
+        await executePromise;
+
+        terminal.verify((t) => t.sendText(TypeMoq.It.isValue(textToSend)), TypeMoq.Times.exactly(1));
+    });
+
     test('Ensure terminal is not shown if `hideFromUser` option is set to `true`', async () => {
         terminalHelper
             .setup((helper) => helper.getEnvironmentActivationCommands(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
diff --git a/src/test/configuration/interpreterSelector/commands/setInterpreter.unit.test.ts b/src/test/configuration/interpreterSelector/commands/setInterpreter.unit.test.ts
index 0016ca339bfe..7837245ec9d2 100644
--- a/src/test/configuration/interpreterSelector/commands/setInterpreter.unit.test.ts
+++ b/src/test/configuration/interpreterSelector/commands/setInterpreter.unit.test.ts
@@ -1052,6 +1052,7 @@ suite('Set Interpreter Command', () => {
                 openLabel: InterpreterQuickPickList.browsePath.openButtonLabel,
                 canSelectMany: false,
                 title: InterpreterQuickPickList.browsePath.title,
+                defaultUri: undefined,
             };
             const multiStepInput = TypeMoq.Mock.ofType<IMultiStepInput<InterpreterStateArgs>>();
             multiStepInput.setup((i) => i.showQuickPick(TypeMoq.It.isAny())).returns(() => Promise.resolve(items[0]));
@@ -1073,6 +1074,27 @@ suite('Set Interpreter Command', () => {
                 openLabel: InterpreterQuickPickList.browsePath.openButtonLabel,
                 canSelectMany: false,
                 title: InterpreterQuickPickList.browsePath.title,
+                defaultUri: undefined,
+            };
+            multiStepInput.setup((i) => i.showQuickPick(TypeMoq.It.isAny())).returns(() => Promise.resolve(items[0]));
+            appShell.setup((a) => a.showOpenDialog(expectedParams)).verifiable(TypeMoq.Times.once());
+            platformService.setup((p) => p.isWindows).returns(() => false);
+
+            await setInterpreterCommand._enterOrBrowseInterpreterPath(multiStepInput.object, state).ignoreErrors();
+
+            appShell.verifyAll();
+        });
+
+        test('If `Browse...` option is selected with workspace, file browser opens at workspace root', async () => {
+            const workspaceUri = Uri.parse('file:///workspace/root');
+            const state: InterpreterStateArgs = { path: undefined, workspace: workspaceUri };
+            const multiStepInput = TypeMoq.Mock.ofType<IMultiStepInput<InterpreterStateArgs>>();
+            const expectedParams = {
+                filters: undefined,
+                openLabel: InterpreterQuickPickList.browsePath.openButtonLabel,
+                canSelectMany: false,
+                title: InterpreterQuickPickList.browsePath.title,
+                defaultUri: workspaceUri,
             };
             multiStepInput.setup((i) => i.showQuickPick(TypeMoq.It.isAny())).returns(() => Promise.resolve(items[0]));
             appShell.setup((a) => a.showOpenDialog(expectedParams)).verifiable(TypeMoq.Times.once());
@@ -1126,6 +1148,7 @@ suite('Set Interpreter Command', () => {
                     openLabel: InterpreterQuickPickList.browsePath.openButtonLabel,
                     canSelectMany: false,
                     title: InterpreterQuickPickList.browsePath.title,
+                    defaultUri: undefined,
                 };
                 multiStepInput
                     .setup((i) => i.showQuickPick(TypeMoq.It.isAny()))
diff --git a/src/test/debugger/envVars.test.ts b/src/test/debugger/envVars.test.ts
index ae21c7fd5d49..8b0f55986281 100644
--- a/src/test/debugger/envVars.test.ts
+++ b/src/test/debugger/envVars.test.ts
@@ -16,6 +16,8 @@ import { isOs, OSType } from '../common';
 import { closeActiveWindows, initialize, initializeTest, IS_MULTI_ROOT_TEST, TEST_DEBUGGER } from '../initialize';
 import { UnitTestIocContainer } from '../testing/serviceRegistry';
 import { normCase } from '../../client/common/platform/fs-paths';
+import { IRecommendedEnvironmentService } from '../../client/interpreter/configuration/types';
+import { RecommendedEnvironmentService } from '../../client/interpreter/configuration/recommededEnvironmentService';
 
 use(chaiAsPromised.default);
 
@@ -53,6 +55,10 @@ suite('Resolving Environment Variables when Debugging', () => {
         ioc.registerFileSystemTypes();
         ioc.registerVariableTypes();
         ioc.registerMockProcess();
+        ioc.serviceManager.addSingleton<IRecommendedEnvironmentService>(
+            IRecommendedEnvironmentService,
+            RecommendedEnvironmentService,
+        );
     }
 
     async function testBasicProperties(console: ConsoleType, expectedNumberOfVariables: number) {
diff --git a/src/test/extensionSettings.ts b/src/test/extensionSettings.ts
index 66a77589a770..2d35dcb5f4ca 100644
--- a/src/test/extensionSettings.ts
+++ b/src/test/extensionSettings.ts
@@ -13,6 +13,7 @@ import { PersistentStateFactory } from '../client/common/persistentState';
 import { IPythonSettings, Resource } from '../client/common/types';
 import { PythonEnvironment } from '../client/pythonEnvironments/info';
 import { MockMemento } from './mocks/mementos';
+import { MockExtensions } from './mocks/extensions';
 
 export function getExtensionSettings(resource: Uri | undefined): IPythonSettings {
     const vscode = require('vscode') as typeof import('vscode');
@@ -41,6 +42,7 @@ export function getExtensionSettings(resource: Uri | undefined): IPythonSettings
     const workspaceMemento = new MockMemento();
     const globalMemento = new MockMemento();
     const persistentStateFactory = new PersistentStateFactory(globalMemento, workspaceMemento);
+    const extensions = new MockExtensions();
     return pythonSettings.PythonSettings.getInstance(
         resource,
         new AutoSelectionService(),
@@ -49,5 +51,6 @@ export function getExtensionSettings(resource: Uri | undefined): IPythonSettings
             remoteName: undefined,
         } as IApplicationEnvironment),
         undefined,
+        extensions,
     );
 }
diff --git a/src/test/interpreters/activation/terminalEnvVarCollectionService.unit.test.ts b/src/test/interpreters/activation/terminalEnvVarCollectionService.unit.test.ts
index 7016a25c7a4e..dfe3ad8c081a 100644
--- a/src/test/interpreters/activation/terminalEnvVarCollectionService.unit.test.ts
+++ b/src/test/interpreters/activation/terminalEnvVarCollectionService.unit.test.ts
@@ -6,12 +6,14 @@
 import * as sinon from 'sinon';
 import { assert, expect } from 'chai';
 import { mock, instance, when, anything, verify, reset } from 'ts-mockito';
+import * as TypeMoq from 'typemoq';
 import {
     EnvironmentVariableCollection,
     EnvironmentVariableMutatorOptions,
     GlobalEnvironmentVariableCollection,
     ProgressLocation,
     Uri,
+    WorkspaceConfiguration,
     WorkspaceFolder,
 } from 'vscode';
 import {
@@ -55,6 +57,7 @@ suite('Terminal Environment Variable Collection Service', () => {
     let terminalEnvVarCollectionService: TerminalEnvVarCollectionService;
     let terminalDeactivateService: ITerminalDeactivateService;
     let useEnvExtensionStub: sinon.SinonStub;
+    let pythonConfig: TypeMoq.IMock<WorkspaceConfiguration>;
     const progressOptions = {
         location: ProgressLocation.Window,
         title: Interpreters.activatingTerminals,
@@ -122,6 +125,8 @@ suite('Terminal Environment Variable Collection Service', () => {
             instance(shellIntegrationService),
             instance(envVarProvider),
         );
+        pythonConfig = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
+        pythonConfig.setup((p) => p.get('terminal.shellIntegration.enabled')).returns(() => false);
     });
 
     teardown(() => {
diff --git a/src/test/interpreters/display.unit.test.ts b/src/test/interpreters/display.unit.test.ts
index 7d53fbfc0561..d9be806ff709 100644
--- a/src/test/interpreters/display.unit.test.ts
+++ b/src/test/interpreters/display.unit.test.ts
@@ -59,7 +59,7 @@ suite('Interpreters Display', () => {
     let pathUtils: TypeMoq.IMock<IPathUtils>;
     let languageStatusItem: TypeMoq.IMock<LanguageStatusItem>;
     let traceLogStub: sinon.SinonStub;
-    let useEnvExtensionStub: sinon.SinonStub;
+    let shouldEnvExtHandleActivationStub: sinon.SinonStub;
     async function createInterpreterDisplay(filters: IInterpreterStatusbarVisibilityFilter[] = []) {
         interpreterDisplay = new InterpreterDisplay(serviceContainer.object);
         try {
@@ -69,8 +69,8 @@ suite('Interpreters Display', () => {
     }
 
     async function setupMocks(useLanguageStatus: boolean) {
-        useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
-        useEnvExtensionStub.returns(false);
+        shouldEnvExtHandleActivationStub = sinon.stub(extapi, 'shouldEnvExtHandleActivation');
+        shouldEnvExtHandleActivationStub.returns(false);
 
         serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
         workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
diff --git a/src/test/interpreters/interpreterPathCommand.unit.test.ts b/src/test/interpreters/interpreterPathCommand.unit.test.ts
index be94be654861..8d45ad82577c 100644
--- a/src/test/interpreters/interpreterPathCommand.unit.test.ts
+++ b/src/test/interpreters/interpreterPathCommand.unit.test.ts
@@ -13,15 +13,19 @@ import * as commandApis from '../../client/common/vscodeApis/commandApis';
 import { InterpreterPathCommand } from '../../client/interpreter/interpreterPathCommand';
 import { IInterpreterService } from '../../client/interpreter/contracts';
 import { PythonEnvironment } from '../../client/pythonEnvironments/info';
+import * as workspaceApis from '../../client/common/vscodeApis/workspaceApis';
 
 suite('Interpreter Path Command', () => {
     let interpreterService: IInterpreterService;
     let interpreterPathCommand: InterpreterPathCommand;
     let registerCommandStub: sinon.SinonStub;
+    let getConfigurationStub: sinon.SinonStub;
+
     setup(() => {
         interpreterService = mock<IInterpreterService>();
         registerCommandStub = sinon.stub(commandApis, 'registerCommand');
         interpreterPathCommand = new InterpreterPathCommand(instance(interpreterService), []);
+        getConfigurationStub = sinon.stub(workspaceApis, 'getConfiguration');
     });
 
     teardown(() => {
@@ -43,7 +47,7 @@ suite('Interpreter Path Command', () => {
     });
 
     test('If `workspaceFolder` property exists in `args`, it is used to retrieve setting from config', async () => {
-        const args = { workspaceFolder: 'folderPath' };
+        const args = { workspaceFolder: 'folderPath', type: 'debugpy' };
         when(interpreterService.getActiveInterpreter(anything())).thenCall((arg) => {
             assert.deepEqual(arg, Uri.file('folderPath'));
 
@@ -76,6 +80,10 @@ suite('Interpreter Path Command', () => {
     });
 
     test('If neither of these exists, value of workspace folder is `undefined`', async () => {
+        getConfigurationStub.withArgs('python').returns({
+            get: sinon.stub().returns(false),
+        });
+
         const args = ['command'];
 
         when(interpreterService.getActiveInterpreter(undefined)).thenReturn(
diff --git a/src/test/interpreters/pythonPathUpdaterFactory.unit.test.ts b/src/test/interpreters/pythonPathUpdaterFactory.unit.test.ts
index 762c23d86c8e..5c851b8071f3 100644
--- a/src/test/interpreters/pythonPathUpdaterFactory.unit.test.ts
+++ b/src/test/interpreters/pythonPathUpdaterFactory.unit.test.ts
@@ -17,6 +17,7 @@ suite('Python Path Settings Updater', () => {
         serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
         workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
         interpreterPathService = TypeMoq.Mock.ofType<IInterpreterPathService>();
+        experimentsManager = TypeMoq.Mock.ofType<IExperimentService>();
         serviceContainer
             .setup((c) => c.get(TypeMoq.It.isValue(IWorkspaceService)))
             .returns(() => workspaceService.object);
diff --git a/src/test/interpreters/recommededEnvironmentService.unit.test.ts b/src/test/interpreters/recommededEnvironmentService.unit.test.ts
new file mode 100644
index 000000000000..7cb5aed58239
--- /dev/null
+++ b/src/test/interpreters/recommededEnvironmentService.unit.test.ts
@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { expect } from 'chai';
+import { anything, reset, verify, when } from 'ts-mockito';
+import { Disposable, Uri } from 'vscode';
+import { mockedVSCodeNamespaces } from '../vscode-mock';
+import { RecommendedEnvironmentService } from '../../client/interpreter/configuration/recommededEnvironmentService';
+
+suite('RecommendedEnvironmentService - activate', () => {
+    let service: RecommendedEnvironmentService;
+    let subscriptions: Disposable[];
+
+    setup(() => {
+        subscriptions = [];
+        const extensionContext = {
+            subscriptions,
+            globalState: {
+                get: () => undefined,
+                update: () => Promise.resolve(),
+            },
+        } as any;
+
+        when(mockedVSCodeNamespaces.commands!.registerCommand(anything(), anything())).thenReturn({
+            dispose: () => {},
+        } as Disposable);
+
+        service = new RecommendedEnvironmentService(extensionContext);
+    });
+
+    teardown(() => {
+        reset(mockedVSCodeNamespaces.commands!);
+    });
+
+    test('Multiroot workspace: command is registered only once across multiple activate calls', async () => {
+        // Simulate multiroot workspace where activate is called once per workspace root
+        const workspaceRoot1 = Uri.file('/workspace/root1');
+        const workspaceRoot2 = Uri.file('/workspace/root2');
+        const workspaceRoot3 = Uri.file('/workspace/root3');
+
+        await service.activate(workspaceRoot1);
+        await service.activate(workspaceRoot2);
+        await service.activate(workspaceRoot3);
+
+        verify(mockedVSCodeNamespaces.commands!.registerCommand('python.getRecommendedEnvironment', anything())).once();
+        expect(subscriptions).to.have.lengthOf(1);
+    });
+});
diff --git a/src/test/interpreters/serviceRegistry.unit.test.ts b/src/test/interpreters/serviceRegistry.unit.test.ts
index a189696c2f82..ad8614b42d8b 100644
--- a/src/test/interpreters/serviceRegistry.unit.test.ts
+++ b/src/test/interpreters/serviceRegistry.unit.test.ts
@@ -27,6 +27,7 @@ import {
     IInterpreterSelector,
     IPythonPathUpdaterServiceFactory,
     IPythonPathUpdaterServiceManager,
+    IRecommendedEnvironmentService,
 } from '../../client/interpreter/configuration/types';
 import {
     IActivatedEnvironmentLaunch,
@@ -44,6 +45,7 @@ import { CondaInheritEnvPrompt } from '../../client/interpreter/virtualEnvs/cond
 import { VirtualEnvironmentPrompt } from '../../client/interpreter/virtualEnvs/virtualEnvPrompt';
 import { ServiceManager } from '../../client/ioc/serviceManager';
 import { InterpreterPathCommand } from '../../client/interpreter/interpreterPathCommand';
+import { RecommendedEnvironmentService } from '../../client/interpreter/configuration/recommededEnvironmentService';
 
 suite('Interpreters - Service Registry', () => {
     test('Registrations', () => {
@@ -64,6 +66,7 @@ suite('Interpreters - Service Registry', () => {
 
             [IPythonPathUpdaterServiceFactory, PythonPathUpdaterServiceFactory],
             [IPythonPathUpdaterServiceManager, PythonPathUpdaterService],
+            [IRecommendedEnvironmentService, RecommendedEnvironmentService],
             [IInterpreterSelector, InterpreterSelector],
             [IInterpreterHelper, InterpreterHelper],
             [IInterpreterComparer, EnvironmentTypeComparer],
diff --git a/src/test/interpreters/virtualEnvs/activatedEnvLaunch.unit.test.ts b/src/test/interpreters/virtualEnvs/activatedEnvLaunch.unit.test.ts
index 2ebdecd000d1..860970bd641e 100644
--- a/src/test/interpreters/virtualEnvs/activatedEnvLaunch.unit.test.ts
+++ b/src/test/interpreters/virtualEnvs/activatedEnvLaunch.unit.test.ts
@@ -263,37 +263,6 @@ suite('Activated Env Launch', async () => {
             expect(_promptIfApplicable.notCalled).to.equal(true, 'Prompt should not be displayed');
         });
 
-        test('Does not update interpreter path if a multiroot workspace is opened', async () => {
-            process.env.VIRTUAL_ENV = virtualEnvPrefix;
-            interpreterService
-                .setup((i) => i.getInterpreterDetails(TypeMoq.It.isAny()))
-                .returns(() => Promise.resolve(({ envName: 'base' } as unknown) as PythonEnvironment));
-            workspaceService.setup((w) => w.workspaceFile).returns(() => uri);
-            const workspaceFolder: WorkspaceFolder = { name: 'one', uri, index: 0 };
-            workspaceService.setup((w) => w.workspaceFolders).returns(() => [workspaceFolder]);
-            pythonPathUpdaterService
-                .setup((p) =>
-                    p.updatePythonPath(
-                        TypeMoq.It.isValue(virtualEnvPrefix),
-                        TypeMoq.It.isValue(ConfigurationTarget.WorkspaceFolder),
-                        TypeMoq.It.isValue('load'),
-                        TypeMoq.It.isValue(uri),
-                    ),
-                )
-                .returns(() => Promise.resolve())
-                .verifiable(TypeMoq.Times.never());
-            activatedEnvLaunch = new ActivatedEnvironmentLaunch(
-                workspaceService.object,
-                appShell.object,
-                pythonPathUpdaterService.object,
-                interpreterService.object,
-                processServiceFactory.object,
-            );
-            const result = await activatedEnvLaunch.selectIfLaunchedViaActivatedEnv();
-            expect(result).to.be.equal(undefined, 'Incorrect value');
-            pythonPathUpdaterService.verifyAll();
-        });
-
         test('Returns `undefined` if env was already selected', async () => {
             activatedEnvLaunch = new ActivatedEnvironmentLaunch(
                 workspaceService.object,
diff --git a/src/test/mocks/extension.ts b/src/test/mocks/extension.ts
new file mode 100644
index 000000000000..61d70eb5ee9e
--- /dev/null
+++ b/src/test/mocks/extension.ts
@@ -0,0 +1,16 @@
+import { injectable } from 'inversify';
+import { Extension, ExtensionKind, Uri } from 'vscode';
+
+@injectable()
+export class MockExtension<T> implements Extension<T> {
+    id!: string;
+    extensionUri!: Uri;
+    extensionPath!: string;
+    isActive!: boolean;
+    packageJSON: any;
+    extensionKind!: ExtensionKind;
+    exports!: T;
+    activate(): Thenable<T> {
+        throw new Error('Method not implemented.');
+    }
+}
diff --git a/src/test/mocks/extensions.ts b/src/test/mocks/extensions.ts
new file mode 100644
index 000000000000..efe9b6b8ca31
--- /dev/null
+++ b/src/test/mocks/extensions.ts
@@ -0,0 +1,23 @@
+import { injectable } from 'inversify';
+import { IExtensions } from '../../client/common/types';
+import { Extension, Event } from 'vscode';
+import { MockExtension } from './extension';
+
+@injectable()
+export class MockExtensions implements IExtensions {
+    extensionIdsToFind: unknown[] = [];
+    all: readonly Extension<unknown>[] = [];
+    onDidChange: Event<void> = () => {
+        throw new Error('Method not implemented');
+    };
+    getExtension(extensionId: string): Extension<unknown> | undefined;
+    getExtension<T>(extensionId: string): Extension<T> | undefined;
+    getExtension(extensionId: unknown): import('vscode').Extension<unknown> | undefined {
+        if (this.extensionIdsToFind.includes(extensionId)) {
+            return new MockExtension();
+        }
+    }
+    determineExtensionFromCallStack(): Promise<{ extensionId: string; displayName: string }> {
+        throw new Error('Method not implemented.');
+    }
+}
diff --git a/src/test/mocks/mockDocument.ts b/src/test/mocks/mockDocument.ts
index 811c591420bd..a9cd39985311 100644
--- a/src/test/mocks/mockDocument.ts
+++ b/src/test/mocks/mockDocument.ts
@@ -84,6 +84,7 @@ export class MockDocument implements TextDocument {
         this._onSave = onSave;
         this._language = language ?? this._language;
     }
+    encoding: string = 'utf8';
 
     public setContent(contents: string): void {
         this._contents = contents;
diff --git a/src/test/mocks/vsc/extHostedTypes.ts b/src/test/mocks/vsc/extHostedTypes.ts
index f87b50174150..c2c1188c3449 100644
--- a/src/test/mocks/vsc/extHostedTypes.ts
+++ b/src/test/mocks/vsc/extHostedTypes.ts
@@ -2000,12 +2000,31 @@ export enum TreeItemCollapsibleState {
     Expanded = 2,
 }
 
+/**
+ * Represents an icon in the UI. This is either an uri, separate uris for the light- and dark-themes,
+ * or a {@link ThemeIcon theme icon}.
+ */
+export type IconPath =
+    | vscUri.URI
+    | {
+          /**
+           * The icon path for the light theme.
+           */
+          light: vscUri.URI;
+          /**
+           * The icon path for the dark theme.
+           */
+          dark: vscUri.URI;
+      }
+    | ThemeIcon;
+
 export class TreeItem {
-    label?: string;
+    label?: string | vscode.TreeItemLabel;
+    id?: string;
 
     resourceUri?: vscUri.URI;
 
-    iconPath?: string | vscUri.URI | { light: string | vscUri.URI; dark: string | vscUri.URI };
+    iconPath?: string | IconPath;
 
     command?: vscode.Command;
 
diff --git a/src/test/providers/terminal.unit.test.ts b/src/test/providers/terminal.unit.test.ts
index ac39ded922c8..8f684835b7cf 100644
--- a/src/test/providers/terminal.unit.test.ts
+++ b/src/test/providers/terminal.unit.test.ts
@@ -29,10 +29,13 @@ suite('Terminal Provider', () => {
     let experimentService: TypeMoq.IMock<IExperimentService>;
     let terminalProvider: TerminalProvider;
     let useEnvExtensionStub: sinon.SinonStub;
+    let shouldEnvExtHandleActivationStub: sinon.SinonStub;
     const resource = Uri.parse('a');
     setup(() => {
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
         useEnvExtensionStub.returns(false);
+        shouldEnvExtHandleActivationStub = sinon.stub(extapi, 'shouldEnvExtHandleActivation');
+        shouldEnvExtHandleActivationStub.returns(false);
 
         serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
         commandManager = TypeMoq.Mock.ofType<ICommandManager>();
diff --git a/src/test/pythonEnvironments/creation/createEnvApi.unit.test.ts b/src/test/pythonEnvironments/creation/createEnvApi.unit.test.ts
index f8c75f76e2b8..dd09203d65cc 100644
--- a/src/test/pythonEnvironments/creation/createEnvApi.unit.test.ts
+++ b/src/test/pythonEnvironments/creation/createEnvApi.unit.test.ts
@@ -7,9 +7,12 @@ import * as sinon from 'sinon';
 import * as typemoq from 'typemoq';
 import { assert, use as chaiUse } from 'chai';
 import { ConfigurationTarget, Uri } from 'vscode';
-import { IDisposableRegistry, IInterpreterPathService, IPathUtils } from '../../../client/common/types';
+import { IDisposableRegistry, IPathUtils } from '../../../client/common/types';
 import * as commandApis from '../../../client/common/vscodeApis/commandApis';
-import { IInterpreterQuickPick } from '../../../client/interpreter/configuration/types';
+import {
+    IInterpreterQuickPick,
+    IPythonPathUpdaterServiceManager,
+} from '../../../client/interpreter/configuration/types';
 import { registerCreateEnvironmentFeatures } from '../../../client/pythonEnvironments/creation/createEnvApi';
 import * as windowApis from '../../../client/common/vscodeApis/windowApis';
 import { handleCreateEnvironmentCommand } from '../../../client/pythonEnvironments/creation/createEnvironment';
@@ -23,7 +26,7 @@ suite('Create Environment APIs', () => {
     let showInformationMessageStub: sinon.SinonStub;
     const disposables: IDisposableRegistry = [];
     let interpreterQuickPick: typemoq.IMock<IInterpreterQuickPick>;
-    let interpreterPathService: typemoq.IMock<IInterpreterPathService>;
+    let interpreterPathService: typemoq.IMock<IPythonPathUpdaterServiceManager>;
     let pathUtils: typemoq.IMock<IPathUtils>;
 
     setup(() => {
@@ -32,7 +35,7 @@ suite('Create Environment APIs', () => {
 
         registerCommandStub = sinon.stub(commandApis, 'registerCommand');
         interpreterQuickPick = typemoq.Mock.ofType<IInterpreterQuickPick>();
-        interpreterPathService = typemoq.Mock.ofType<IInterpreterPathService>();
+        interpreterPathService = typemoq.Mock.ofType<IPythonPathUpdaterServiceManager>();
         pathUtils = typemoq.Mock.ofType<IPathUtils>();
 
         registerCommandStub.callsFake((_command: string, _callback: (...args: any[]) => any) => ({
@@ -82,10 +85,11 @@ suite('Create Environment APIs', () => {
 
             interpreterPathService
                 .setup((p) =>
-                    p.update(
-                        typemoq.It.isAny(),
-                        ConfigurationTarget.WorkspaceFolder,
+                    p.updatePythonPath(
                         typemoq.It.isValue('/path/to/env'),
+                        ConfigurationTarget.WorkspaceFolder,
+                        'ui',
+                        typemoq.It.isAny(),
                     ),
                 )
                 .returns(() => Promise.resolve())
diff --git a/src/test/pythonEnvironments/creation/pyProjectTomlContext.unit.test.ts b/src/test/pythonEnvironments/creation/pyProjectTomlContext.unit.test.ts
index 8363837a4a36..3e787570304a 100644
--- a/src/test/pythonEnvironments/creation/pyProjectTomlContext.unit.test.ts
+++ b/src/test/pythonEnvironments/creation/pyProjectTomlContext.unit.test.ts
@@ -28,7 +28,7 @@ function getInstallableToml(): typemoq.IMock<TextDocument> {
         .setup((p) => p.getText(typemoq.It.isAny()))
         .returns(
             () =>
-                '[project]\nname = "spam"\nversion = "2020.0.0"\n[build-system]\nrequires = ["setuptools ~= 58.0", "cython ~= 0.29.0"]\n[project.optional-dependencies]\ntest = ["pytest"]\ndoc = ["sphinx", "furo"]',
+                '[project]\nname = "spam"\nversion = "2020.0.0"\n[build-system]\nrequires = ["setuptools ~= 58.0", "cython ~= 0.29.0"]\n[dependency-groups]\ndev = ["ruff", { include-group = "test" }]\ntest = ["pytest"]',
         );
     return pyprojectToml;
 }
diff --git a/src/test/pythonEnvironments/nativeAPI.unit.test.ts b/src/test/pythonEnvironments/nativeAPI.unit.test.ts
index 74811fa63bb6..a3696b59c6ac 100644
--- a/src/test/pythonEnvironments/nativeAPI.unit.test.ts
+++ b/src/test/pythonEnvironments/nativeAPI.unit.test.ts
@@ -53,8 +53,8 @@ suite('Native Python API', () => {
     const expectedBasicEnv: PythonEnvInfo = {
         arch: Architecture.Unknown,
         id: '/usr/bin/python',
-        detailedDisplayName: "Python 3.12.0 ('basic_python')",
-        display: "Python 3.12.0 ('basic_python')",
+        detailedDisplayName: 'Python 3.12.0 (basic_python)',
+        display: 'Python 3.12.0 (basic_python)',
         distro: { org: '' },
         executable: { filename: '/usr/bin/python', sysPrefix: '/usr/bin', ctime: -1, mtime: -1 },
         kind: PythonEnvKind.System,
@@ -98,8 +98,8 @@ suite('Native Python API', () => {
 
     const expectedConda1: PythonEnvInfo = {
         arch: Architecture.Unknown,
-        detailedDisplayName: "Python 3.12.0 ('conda_python')",
-        display: "Python 3.12.0 ('conda_python')",
+        detailedDisplayName: 'Python 3.12.0 (conda_python)',
+        display: 'Python 3.12.0 (conda_python)',
         distro: { org: '' },
         id: '/home/user/.conda/envs/conda_python/python',
         executable: {
diff --git a/src/test/repl/nativeRepl.test.ts b/src/test/repl/nativeRepl.test.ts
index 999bc656c64d..2cf18cefe1f7 100644
--- a/src/test/repl/nativeRepl.test.ts
+++ b/src/test/repl/nativeRepl.test.ts
@@ -1,14 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
 /* eslint-disable no-unused-expressions */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import * as TypeMoq from 'typemoq';
 import * as sinon from 'sinon';
-import { Disposable } from 'vscode';
+import { Disposable, EventEmitter, NotebookDocument, Uri } from 'vscode';
 import { expect } from 'chai';
 
 import { IInterpreterService } from '../../client/interpreter/contracts';
 import { PythonEnvironment } from '../../client/pythonEnvironments/info';
-import { getNativeRepl, NativeRepl } from '../../client/repl/nativeRepl';
+import * as NativeReplModule from '../../client/repl/nativeRepl';
 import * as persistentState from '../../client/common/persistentState';
+import * as PythonServer from '../../client/repl/pythonServer';
+import * as vscodeWorkspaceApis from '../../client/common/vscodeApis/workspaceApis';
+import * as replController from '../../client/repl/replController';
+import { executeCommand } from '../../client/common/vscodeApis/commandApis';
 
 suite('REPL - Native REPL', () => {
     let interpreterService: TypeMoq.IMock<IInterpreterService>;
@@ -19,8 +26,20 @@ suite('REPL - Native REPL', () => {
     let setReplControllerSpy: sinon.SinonSpy;
     let getWorkspaceStateValueStub: sinon.SinonStub;
     let updateWorkspaceStateValueStub: sinon.SinonStub;
+    let createReplControllerStub: sinon.SinonStub;
+    let mockNotebookController: any;
 
     setup(() => {
+        (NativeReplModule as any).nativeRepl = undefined;
+
+        mockNotebookController = {
+            id: 'mockController',
+            dispose: sinon.stub(),
+            updateNotebookAffinity: sinon.stub(),
+            createNotebookCellExecution: sinon.stub(),
+            variableProvider: null,
+        };
+
         interpreterService = TypeMoq.Mock.ofType<IInterpreterService>();
         interpreterService
             .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
@@ -28,13 +47,13 @@ suite('REPL - Native REPL', () => {
         disposable = TypeMoq.Mock.ofType<Disposable>();
         disposableArray = [disposable.object];
 
-        setReplDirectoryStub = sinon.stub(NativeRepl.prototype as any, 'setReplDirectory').resolves(); // Stubbing private method
-        // Use a spy instead of a stub for setReplController
-        setReplControllerSpy = sinon.spy(NativeRepl.prototype, 'setReplController');
+        createReplControllerStub = sinon.stub(replController, 'createReplController').returns(mockNotebookController);
+        setReplDirectoryStub = sinon.stub(NativeReplModule.NativeRepl.prototype as any, 'setReplDirectory').resolves();
+        setReplControllerSpy = sinon.spy(NativeReplModule.NativeRepl.prototype, 'setReplController');
         updateWorkspaceStateValueStub = sinon.stub(persistentState, 'updateWorkspaceStateValue').resolves();
     });
 
-    teardown(() => {
+    teardown(async () => {
         disposableArray.forEach((d) => {
             if (d) {
                 d.dispose();
@@ -42,15 +61,16 @@ suite('REPL - Native REPL', () => {
         });
         disposableArray = [];
         sinon.restore();
+        executeCommand('workbench.action.closeActiveEditor');
     });
 
     test('getNativeRepl should call create constructor', async () => {
-        const createMethodStub = sinon.stub(NativeRepl, 'create');
+        const createMethodStub = sinon.stub(NativeReplModule.NativeRepl, 'create');
         interpreterService
             .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
             .returns(() => Promise.resolve(({ path: 'ps' } as unknown) as PythonEnvironment));
         const interpreter = await interpreterService.object.getActiveInterpreter();
-        await getNativeRepl(interpreter as PythonEnvironment, disposableArray);
+        await NativeReplModule.getNativeRepl(interpreter as PythonEnvironment, disposableArray);
 
         expect(createMethodStub.calledOnce).to.be.true;
     });
@@ -61,7 +81,7 @@ suite('REPL - Native REPL', () => {
             .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
             .returns(() => Promise.resolve(({ path: 'ps' } as unknown) as PythonEnvironment));
         const interpreter = await interpreterService.object.getActiveInterpreter();
-        const nativeRepl = await getNativeRepl(interpreter as PythonEnvironment, disposableArray);
+        const nativeRepl = await NativeReplModule.getNativeRepl(interpreter as PythonEnvironment, disposableArray);
 
         nativeRepl.sendToNativeRepl(undefined, false);
 
@@ -74,7 +94,7 @@ suite('REPL - Native REPL', () => {
             .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
             .returns(() => Promise.resolve(({ path: 'ps' } as unknown) as PythonEnvironment));
         const interpreter = await interpreterService.object.getActiveInterpreter();
-        const nativeRepl = await getNativeRepl(interpreter as PythonEnvironment, disposableArray);
+        const nativeRepl = await NativeReplModule.getNativeRepl(interpreter as PythonEnvironment, disposableArray);
 
         nativeRepl.sendToNativeRepl(undefined, false);
 
@@ -87,12 +107,83 @@ suite('REPL - Native REPL', () => {
             .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
             .returns(() => Promise.resolve(({ path: 'ps' } as unknown) as PythonEnvironment));
 
-        await NativeRepl.create(interpreter as PythonEnvironment);
+        await NativeReplModule.NativeRepl.create(interpreter as PythonEnvironment);
 
         expect(setReplDirectoryStub.calledOnce).to.be.true;
         expect(setReplControllerSpy.calledOnce).to.be.true;
+        expect(createReplControllerStub.calledOnce).to.be.true;
+    });
+
+    test('watchNotebookClosed should clean up resources when notebook is closed', async () => {
+        const notebookCloseEmitter = new EventEmitter<NotebookDocument>();
+        sinon.stub(vscodeWorkspaceApis, 'onDidCloseNotebookDocument').callsFake((handler) => {
+            const disposable = notebookCloseEmitter.event(handler);
+            return disposable;
+        });
+
+        const mockPythonServer = {
+            onCodeExecuted: new EventEmitter<void>().event,
+            execute: sinon.stub().resolves({ status: true, output: 'test output' }),
+            executeSilently: sinon.stub().resolves({ status: true, output: 'test output' }),
+            interrupt: sinon.stub(),
+            input: sinon.stub(),
+            checkValidCommand: sinon.stub().resolves(true),
+            dispose: sinon.stub(),
+            isExecuting: false,
+            isDisposed: false,
+        };
+
+        // Track the number of times createPythonServer was called
+        let createPythonServerCallCount = 0;
+        sinon.stub(PythonServer, 'createPythonServer').callsFake(() => {
+            // eslint-disable-next-line no-plusplus
+            createPythonServerCallCount++;
+            return mockPythonServer;
+        });
+
+        const interpreter = await interpreterService.object.getActiveInterpreter();
 
-        setReplDirectoryStub.restore();
-        setReplControllerSpy.restore();
+        // Create NativeRepl directly to have more control over its state, go around private constructor.
+        const nativeRepl = new (NativeReplModule.NativeRepl as any)();
+        nativeRepl.interpreter = interpreter as PythonEnvironment;
+        nativeRepl.cwd = '/helloJustMockedCwd/cwd';
+        nativeRepl.pythonServer = mockPythonServer;
+        nativeRepl.replController = mockNotebookController;
+        nativeRepl.disposables = [];
+
+        // Make the singleton point to our instance for testing
+        // Otherwise, it gets mixed with Native Repl from .create from test above.
+        (NativeReplModule as any).nativeRepl = nativeRepl;
+
+        // Reset call count after initial setup
+        createPythonServerCallCount = 0;
+
+        // Set notebookDocument to a mock document
+        const mockReplUri = Uri.parse('untitled:Untitled-999.ipynb?jupyter-notebook');
+        const mockNotebookDocument = ({
+            uri: mockReplUri,
+            toString: () => mockReplUri.toString(),
+        } as unknown) as NotebookDocument;
+
+        nativeRepl.notebookDocument = mockNotebookDocument;
+
+        // Create a mock notebook document for closing event with same URI
+        const closingNotebookDocument = ({
+            uri: mockReplUri,
+            toString: () => mockReplUri.toString(),
+        } as unknown) as NotebookDocument;
+
+        notebookCloseEmitter.fire(closingNotebookDocument);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        expect(
+            updateWorkspaceStateValueStub.calledWith(NativeReplModule.NATIVE_REPL_URI_MEMENTO, undefined),
+            'updateWorkspaceStateValue should be called with NATIVE_REPL_URI_MEMENTO and undefined',
+        ).to.be.true;
+        expect(mockPythonServer.dispose.calledOnce, 'pythonServer.dispose() should be called once').to.be.true;
+        expect(createPythonServerCallCount, 'createPythonServer should be called to create a new server').to.equal(1);
+        expect(nativeRepl.notebookDocument, 'notebookDocument should be undefined after closing').to.be.undefined;
+        expect(nativeRepl.newReplSession, 'newReplSession should be set to true after closing').to.be.true;
+        expect(mockNotebookController.dispose.calledOnce, 'replController.dispose() should be called once').to.be.true;
     });
 });
diff --git a/src/test/repl/replCommand.test.ts b/src/test/repl/replCommand.test.ts
index 7c26ebd69c80..0b5edda863f9 100644
--- a/src/test/repl/replCommand.test.ts
+++ b/src/test/repl/replCommand.test.ts
@@ -1,6 +1,6 @@
 // Create test suite and test cases for the `replUtils` module
 import * as TypeMoq from 'typemoq';
-import { Disposable } from 'vscode';
+import { commands, Disposable, Uri } from 'vscode';
 import * as sinon from 'sinon';
 import { expect } from 'chai';
 import { IInterpreterService } from '../../client/interpreter/contracts';
@@ -9,6 +9,7 @@ import { ICodeExecutionHelper } from '../../client/terminals/types';
 import * as replCommands from '../../client/repl/replCommands';
 import * as replUtils from '../../client/repl/replUtils';
 import * as nativeRepl from '../../client/repl/nativeRepl';
+import * as windowApis from '../../client/common/vscodeApis/windowApis';
 import { Commands } from '../../client/common/constants';
 import { PythonEnvironment } from '../../client/pythonEnvironments/info';
 
@@ -203,3 +204,47 @@ suite('REPL - register native repl command', () => {
         sinon.assert.notCalled(getNativeReplStub);
     });
 });
+
+suite('Native REPL getActiveInterpreter', () => {
+    let interpreterService: TypeMoq.IMock<IInterpreterService>;
+    let executeCommandStub: sinon.SinonStub;
+    let getActiveResourceStub: sinon.SinonStub;
+
+    setup(() => {
+        interpreterService = TypeMoq.Mock.ofType<IInterpreterService>();
+        executeCommandStub = sinon.stub(commands, 'executeCommand').resolves(undefined);
+        getActiveResourceStub = sinon.stub(windowApis, 'getActiveResource');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('Uses active resource when uri is undefined', async () => {
+        const resource = Uri.file('/workspace/app.py');
+        const expected = ({ path: 'ps' } as unknown) as PythonEnvironment;
+        getActiveResourceStub.returns(resource);
+        interpreterService
+            .setup((i) => i.getActiveInterpreter(TypeMoq.It.isValue(resource)))
+            .returns(() => Promise.resolve(expected));
+
+        const result = await replUtils.getActiveInterpreter(undefined, interpreterService.object);
+
+        expect(result).to.equal(expected);
+        interpreterService.verify((i) => i.getActiveInterpreter(TypeMoq.It.isValue(resource)), TypeMoq.Times.once());
+        sinon.assert.notCalled(executeCommandStub);
+    });
+
+    test('Triggers environment selection using active resource when interpreter is missing', async () => {
+        const resource = Uri.file('/workspace/app.py');
+        getActiveResourceStub.returns(resource);
+        interpreterService
+            .setup((i) => i.getActiveInterpreter(TypeMoq.It.isValue(resource)))
+            .returns(() => Promise.resolve(undefined));
+
+        const result = await replUtils.getActiveInterpreter(undefined, interpreterService.object);
+
+        expect(result).to.equal(undefined);
+        sinon.assert.calledWith(executeCommandStub, Commands.TriggerEnvironmentSelection, resource);
+    });
+});
diff --git a/src/test/serviceRegistry.ts b/src/test/serviceRegistry.ts
index a0919752cefd..382659b3f838 100644
--- a/src/test/serviceRegistry.ts
+++ b/src/test/serviceRegistry.ts
@@ -27,11 +27,10 @@ import {
     ICurrentProcess,
     IDisposableRegistry,
     IMemento,
-    ILogOutputChannel,
     IPathUtils,
     IsWindows,
     WORKSPACE_MEMENTO,
-    ITestOutputChannel,
+    ILogOutputChannel,
 } from '../client/common/types';
 import { registerTypes as variableRegisterTypes } from '../client/common/variables/serviceRegistry';
 import { EnvironmentActivationService } from '../client/interpreter/activation/service';
@@ -84,7 +83,7 @@ export class IocContainer {
         this.serviceManager.addSingletonInstance<ILogOutputChannel>(ILogOutputChannel, stdOutputChannel);
         const testOutputChannel = new MockOutputChannel('Python Test - UnitTests');
         this.disposables.push(testOutputChannel);
-        this.serviceManager.addSingletonInstance<ITestOutputChannel>(ITestOutputChannel, testOutputChannel);
+        this.serviceManager.addSingletonInstance<ILogOutputChannel>(ILogOutputChannel, testOutputChannel);
 
         this.serviceManager.addSingleton<IInterpreterAutoSelectionService>(
             IInterpreterAutoSelectionService,
diff --git a/src/test/smoke/runInTerminal.smoke.test.ts b/src/test/smoke/runInTerminal.smoke.test.ts
index bd4c88e44e80..4bdec0843862 100644
--- a/src/test/smoke/runInTerminal.smoke.test.ts
+++ b/src/test/smoke/runInTerminal.smoke.test.ts
@@ -17,13 +17,22 @@ suite('Smoke Test: Run Python File In Terminal', () => {
             return this.skip();
         }
         await initialize();
+        // Ensure the environments extension is not used for this test
+        await vscode.workspace
+            .getConfiguration('python')
+            .update('useEnvironmentsExtension', false, vscode.ConfigurationTarget.Global);
         return undefined;
     });
+
     setup(initializeTest);
     suiteTeardown(closeActiveWindows);
     teardown(closeActiveWindows);
 
-    test('Exec', async () => {
+    // TODO: Re-enable this test once the flakiness on Windows is resolved
+    test('Exec', async function () {
+        if (process.platform === 'win32') {
+            return this.skip();
+        }
         const file = path.join(
             EXTENSION_ROOT_DIR_FOR_TESTS,
             'src',
diff --git a/src/test/smoke/smartSend.smoke.test.ts b/src/test/smoke/smartSend.smoke.test.ts
index dc1f07f047e7..cae41cc094d5 100644
--- a/src/test/smoke/smartSend.smoke.test.ts
+++ b/src/test/smoke/smartSend.smoke.test.ts
@@ -19,7 +19,8 @@ suite('Smoke Test: Run Smart Selection and Advance Cursor', async () => {
     suiteTeardown(closeActiveWindows);
     teardown(closeActiveWindows);
 
-    test('Smart Send', async () => {
+    // TODO: Re-enable this test once the flakiness on Windows, linux are resolved
+    test.skip('Smart Send', async function () {
         const file = path.join(
             EXTENSION_ROOT_DIR_FOR_TESTS,
             'src',
diff --git a/src/test/standardTest.ts b/src/test/standardTest.ts
index 00eb3d7cf8c4..c3a7968c9c7a 100644
--- a/src/test/standardTest.ts
+++ b/src/test/standardTest.ts
@@ -89,7 +89,7 @@ async function start() {
     console.log('VS Code executable', vscodeExecutablePath);
     const launchArgs = baseLaunchArgs
         .concat([workspacePath])
-        .concat(channel === 'insiders' ? ['--enable-proposed-api'] : [])
+        .concat(['--enable-proposed-api'])
         .concat(['--timeout', '5000']);
     console.log(`Starting vscode ${channel} with args ${launchArgs.join(' ')}`);
     const options: TestOptions = {
diff --git a/src/test/terminals/activation.unit.test.ts b/src/test/terminals/activation.unit.test.ts
index dea0c891229d..4c5294a82f49 100644
--- a/src/test/terminals/activation.unit.test.ts
+++ b/src/test/terminals/activation.unit.test.ts
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import { anything, instance, mock, verify, when } from 'ts-mockito';
+import * as sinon from 'sinon';
 import { EventEmitter, Terminal } from 'vscode';
 import { ActiveResourceService } from '../../client/common/application/activeResource';
 import { TerminalManager } from '../../client/common/application/terminalManager';
@@ -11,6 +12,7 @@ import { ITerminalActivator } from '../../client/common/terminal/types';
 import { TerminalAutoActivation } from '../../client/terminals/activation';
 import { ITerminalAutoActivation } from '../../client/terminals/types';
 import { noop } from '../core';
+import * as extapi from '../../client/envExt/api.internal';
 
 suite('Terminal', () => {
     suite('Terminal Auto Activation', () => {
@@ -21,8 +23,12 @@ suite('Terminal', () => {
         let onDidOpenTerminalEventEmitter: EventEmitter<Terminal>;
         let terminal: Terminal;
         let nonActivatedTerminal: Terminal;
+        let shouldEnvExtHandleActivationStub: sinon.SinonStub;
 
         setup(() => {
+            shouldEnvExtHandleActivationStub = sinon.stub(extapi, 'shouldEnvExtHandleActivation');
+            shouldEnvExtHandleActivationStub.returns(false);
+
             manager = mock(TerminalManager);
             activator = mock(TerminalActivator);
             resourceService = mock(ActiveResourceService);
@@ -60,6 +66,9 @@ suite('Terminal', () => {
             autoActivation.register();
         });
         // teardown(() => fakeTimer.uninstall());
+        teardown(() => {
+            sinon.restore();
+        });
 
         test('Should activate terminal', async () => {
             // Trigger opening a terminal.
@@ -77,5 +86,12 @@ suite('Terminal', () => {
             // The terminal should get activated.
             verify(activator.activateEnvironmentInTerminal(anything(), anything())).never();
         });
+        test('Should not activate terminal when envs extension should handle activation', async () => {
+            shouldEnvExtHandleActivationStub.returns(true);
+
+            await ((onDidOpenTerminalEventEmitter.fire(terminal) as unknown) as Promise<void>);
+
+            verify(activator.activateEnvironmentInTerminal(anything(), anything())).never();
+        });
     });
 });
diff --git a/src/test/terminals/codeExecution/helper.test.ts b/src/test/terminals/codeExecution/helper.test.ts
index a43c5f8746ed..b7e0d1617884 100644
--- a/src/test/terminals/codeExecution/helper.test.ts
+++ b/src/test/terminals/codeExecution/helper.test.ts
@@ -137,7 +137,7 @@ suite('Terminal - Code Execution Helper', async () => {
         editor.setup((e) => e.document).returns(() => document.object);
     });
 
-    test('normalizeLines should handle attach_bracket_paste correctly', async () => {
+    test('normalizeLines with BASIC_REPL does not attach bracketed paste mode', async () => {
         configurationService
             .setup((c) => c.getSettings(TypeMoq.It.isAny()))
             .returns({
@@ -163,7 +163,7 @@ suite('Terminal - Code Execution Helper', async () => {
 
         const result = await helper.normalizeLines('print("Looks like you are on 3.13")', ReplType.terminal);
 
-        expect(result).to.equal(`\u001b[200~print("Looks like you are on 3.13")\u001b[201~`);
+        expect(result).to.equal(`print("Looks like you are on 3.13")`);
         jsonParseStub.restore();
     });
 
diff --git a/src/test/terminals/shellIntegration/pythonStartup.test.ts b/src/test/terminals/shellIntegration/pythonStartup.test.ts
index 45535d0ceecc..833a4f29e972 100644
--- a/src/test/terminals/shellIntegration/pythonStartup.test.ts
+++ b/src/test/terminals/shellIntegration/pythonStartup.test.ts
@@ -135,6 +135,15 @@ suite('Terminal - Shell Integration with PYTHONSTARTUP', () => {
         globalEnvironmentVariableCollection.verify((c) => c.delete('PYTHONSTARTUP'), TypeMoq.Times.once());
     });
 
+    test('PYTHON_BASIC_REPL is set when shell integration is enabled', async () => {
+        pythonConfig.setup((p) => p.get('terminal.shellIntegration.enabled')).returns(() => true);
+        await registerPythonStartup(context.object);
+        globalEnvironmentVariableCollection.verify(
+            (c) => c.replace('PYTHON_BASIC_REPL', '1', TypeMoq.It.isAny()),
+            TypeMoq.Times.once(),
+        );
+    });
+
     test('Ensure registering terminal link calls registerTerminalLinkProvider', async () => {
         const registerTerminalLinkProviderStub = sinon.stub(
             pythonStartupLinkProvider,
diff --git a/src/test/testing/common/debugLauncher.unit.test.ts b/src/test/testing/common/debugLauncher.unit.test.ts
index 397ae03eafc2..86e862103bf6 100644
--- a/src/test/testing/common/debugLauncher.unit.test.ts
+++ b/src/test/testing/common/debugLauncher.unit.test.ts
@@ -30,6 +30,7 @@ import { TestProvider } from '../../../client/testing/types';
 import { isOs, OSType } from '../../common';
 import { IEnvironmentActivationService } from '../../../client/interpreter/activation/types';
 import { createDeferred } from '../../../client/common/utils/async';
+import * as envExtApi from '../../../client/envExt/api.internal';
 
 use(chaiAsPromised.default);
 
@@ -106,7 +107,7 @@ suite('Unit Tests - Debug Launcher', () => {
         );
     }
     function setupDebugManager(
-        workspaceFolder: WorkspaceFolder,
+        _workspaceFolder: WorkspaceFolder,
         expected: DebugConfiguration,
         testProvider: TestProvider,
     ) {
@@ -123,35 +124,48 @@ suite('Unit Tests - Debug Launcher', () => {
             .returns(() => Promise.resolve(expected.env));
 
         const deferred = createDeferred<void>();
+        let capturedConfig: DebugConfiguration | undefined;
 
+        // Use TypeMoq.It.isAny() because the implementation adds a session marker to the config
         debugService
-            .setup((d) =>
-                d.startDebugging(TypeMoq.It.isValue(workspaceFolder), TypeMoq.It.isValue(expected), undefined),
-            )
-            .returns((_wspc: WorkspaceFolder, _expectedParam: DebugConfiguration) => {
+            .setup((d) => d.startDebugging(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .callback((_wspc: WorkspaceFolder, config: DebugConfiguration) => {
+                capturedConfig = config;
                 deferred.resolve();
-                return Promise.resolve(undefined as any);
-            });
-
-        // create a fake debug session that the debug service will return on terminate
-        const fakeDebugSession = TypeMoq.Mock.ofType<DebugSession>();
-        fakeDebugSession.setup((ds) => ds.id).returns(() => 'id-val');
-        const debugSessionInstance = fakeDebugSession.object;
+            })
+            .returns(() => Promise.resolve(true));
 
+        // Setup onDidStartDebugSession - the new implementation uses this to capture the session
         debugService
-            .setup((d) => d.activeDebugSession)
-            .returns(() => debugSessionInstance)
-            .verifiable(TypeMoq.Times.once());
+            .setup((d) => d.onDidStartDebugSession(TypeMoq.It.isAny()))
+            .returns((callback) => {
+                deferred.promise.then(() => {
+                    if (capturedConfig) {
+                        callback(({
+                            id: 'test-session-id',
+                            configuration: capturedConfig,
+                        } as unknown) as DebugSession);
+                    }
+                });
+                return { dispose: () => {} };
+            });
 
+        // Setup onDidTerminateDebugSession - fires after the session starts
         debugService
             .setup((d) => d.onDidTerminateDebugSession(TypeMoq.It.isAny()))
             .returns((callback) => {
                 deferred.promise.then(() => {
-                    callback(debugSessionInstance);
+                    setTimeout(() => {
+                        if (capturedConfig) {
+                            callback(({
+                                id: 'test-session-id',
+                                configuration: capturedConfig,
+                            } as unknown) as DebugSession);
+                        }
+                    }, 10);
                 });
-                return undefined as any;
-            })
-            .verifiable(TypeMoq.Times.once());
+                return { dispose: () => {} };
+            });
     }
     function createWorkspaceFolder(folderPath: string): WorkspaceFolder {
         return {
@@ -692,4 +706,228 @@ suite('Unit Tests - Debug Launcher', () => {
 
         expect(configs).to.be.deep.equal([]);
     });
+
+    // ===== PROJECT-BASED DEBUG SESSION TESTS =====
+
+    suite('Project-based debug sessions', () => {
+        function setupForProjectTests(options: LaunchOptions) {
+            interpreterService
+                .setup((i) => i.getActiveInterpreter(TypeMoq.It.isAny()))
+                .returns(() => Promise.resolve(({ path: 'python' } as unknown) as PythonEnvironment));
+            settings.setup((p) => p.envFile).returns(() => __filename);
+
+            debugEnvHelper
+                .setup((x) => x.getEnvironmentVariables(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+                .returns(() => Promise.resolve({}));
+
+            const workspaceFolders = [{ index: 0, name: 'test', uri: Uri.file(options.cwd) }];
+            getWorkspaceFoldersStub.returns(workspaceFolders);
+            getWorkspaceFolderStub.returns(workspaceFolders[0]);
+            pathExistsStub.resolves(false);
+
+            // Stub useEnvExtension to avoid null reference errors in tests
+            sinon.stub(envExtApi, 'useEnvExtension').returns(false);
+        }
+
+        /**
+         * Helper to setup debug service mocks with proper session lifecycle simulation.
+         * The implementation uses onDidStartDebugSession to capture the session via marker,
+         * then onDidTerminateDebugSession to resolve when that session ends.
+         */
+        function setupDebugServiceWithSessionLifecycle(): {
+            capturedConfigs: DebugConfiguration[];
+        } {
+            const capturedConfigs: DebugConfiguration[] = [];
+            let startCallback: ((session: DebugSession) => void) | undefined;
+            let terminateCallback: ((session: DebugSession) => void) | undefined;
+
+            debugService
+                .setup((d) => d.startDebugging(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+                .callback((_, config) => {
+                    capturedConfigs.push(config);
+                    // Simulate the full session lifecycle after startDebugging resolves
+                    setTimeout(() => {
+                        const session = ({
+                            id: `session-${capturedConfigs.length}`,
+                            configuration: config,
+                        } as unknown) as DebugSession;
+                        // Fire start first (so ourSession is captured)
+                        startCallback?.(session);
+                        // Then fire terminate (so the promise resolves)
+                        setTimeout(() => terminateCallback?.(session), 5);
+                    }, 5);
+                })
+                .returns(() => Promise.resolve(true));
+
+            debugService
+                .setup((d) => d.onDidStartDebugSession(TypeMoq.It.isAny()))
+                .callback((cb) => {
+                    startCallback = cb;
+                })
+                .returns(() => ({ dispose: () => {} }));
+
+            debugService
+                .setup((d) => d.onDidTerminateDebugSession(TypeMoq.It.isAny()))
+                .callback((cb) => {
+                    terminateCallback = cb;
+                })
+                .returns(() => ({ dispose: () => {} }));
+
+            return { capturedConfigs };
+        }
+
+        test('should use project name in config name when provided', async () => {
+            const options: LaunchOptions = {
+                cwd: 'one/two/three',
+                args: ['/one/two/three/testfile.py'],
+                testProvider: 'pytest',
+                runTestIdsPort: 'runTestIdsPort',
+                pytestPort: 'pytestPort',
+                project: { name: 'myproject (Python 3.11)', uri: Uri.file('one/two/three') },
+            };
+
+            setupForProjectTests(options);
+            const { capturedConfigs } = setupDebugServiceWithSessionLifecycle();
+
+            await debugLauncher.launchDebugger(options);
+
+            expect(capturedConfigs).to.have.length(1);
+            expect(capturedConfigs[0].name).to.equal('Debug Tests: myproject (Python 3.11)');
+        });
+
+        test('should use default python when no project provided', async () => {
+            const options: LaunchOptions = {
+                cwd: 'one/two/three',
+                args: ['/one/two/three/testfile.py'],
+                testProvider: 'pytest',
+                runTestIdsPort: 'runTestIdsPort',
+                pytestPort: 'pytestPort',
+            };
+
+            setupForProjectTests(options);
+            const { capturedConfigs } = setupDebugServiceWithSessionLifecycle();
+
+            await debugLauncher.launchDebugger(options);
+
+            expect(capturedConfigs).to.have.length(1);
+            // Should use the default 'python' from interpreterService mock
+            expect(capturedConfigs[0].python).to.equal('python');
+        });
+
+        test('should add unique session marker to launch config', async () => {
+            const options: LaunchOptions = {
+                cwd: 'one/two/three',
+                args: ['/one/two/three/testfile.py'],
+                testProvider: 'pytest',
+                runTestIdsPort: 'runTestIdsPort',
+                pytestPort: 'pytestPort',
+            };
+
+            setupForProjectTests(options);
+            const { capturedConfigs } = setupDebugServiceWithSessionLifecycle();
+
+            await debugLauncher.launchDebugger(options);
+
+            expect(capturedConfigs).to.have.length(1);
+            // Should have a session marker of format 'test-{timestamp}-{random}'
+            const marker = (capturedConfigs[0] as any).__vscodeTestSessionMarker;
+            expect(marker).to.be.a('string');
+            expect(marker).to.match(/^test-\d+-[a-z0-9]+$/);
+        });
+
+        test('should generate unique markers for each launch', async () => {
+            const options: LaunchOptions = {
+                cwd: 'one/two/three',
+                args: ['/one/two/three/testfile.py'],
+                testProvider: 'pytest',
+                runTestIdsPort: 'runTestIdsPort',
+                pytestPort: 'pytestPort',
+            };
+
+            setupForProjectTests(options);
+            const { capturedConfigs } = setupDebugServiceWithSessionLifecycle();
+
+            // Launch twice
+            await debugLauncher.launchDebugger(options);
+            await debugLauncher.launchDebugger(options);
+
+            expect(capturedConfigs).to.have.length(2);
+            const marker1 = (capturedConfigs[0] as any).__vscodeTestSessionMarker;
+            const marker2 = (capturedConfigs[1] as any).__vscodeTestSessionMarker;
+            expect(marker1).to.not.equal(marker2);
+        });
+
+        test('should only resolve when matching session terminates', async () => {
+            const options: LaunchOptions = {
+                cwd: 'one/two/three',
+                args: ['/one/two/three/testfile.py'],
+                testProvider: 'pytest',
+                runTestIdsPort: 'runTestIdsPort',
+                pytestPort: 'pytestPort',
+            };
+
+            setupForProjectTests(options);
+
+            let capturedConfig: DebugConfiguration | undefined;
+            let terminateCallback: ((session: DebugSession) => void) | undefined;
+            let startCallback: ((session: DebugSession) => void) | undefined;
+
+            debugService
+                .setup((d) => d.startDebugging(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+                .callback((_, config) => {
+                    capturedConfig = config;
+                })
+                .returns(() => Promise.resolve(true));
+
+            debugService
+                .setup((d) => d.onDidStartDebugSession(TypeMoq.It.isAny()))
+                .callback((cb) => {
+                    startCallback = cb;
+                })
+                .returns(() => ({ dispose: () => {} }));
+
+            debugService
+                .setup((d) => d.onDidTerminateDebugSession(TypeMoq.It.isAny()))
+                .callback((cb) => {
+                    terminateCallback = cb;
+                })
+                .returns(() => ({ dispose: () => {} }));
+
+            const launchPromise = debugLauncher.launchDebugger(options);
+
+            // Wait for config to be captured
+            await new Promise((r) => setTimeout(r, 10));
+
+            // Simulate our session starting
+            const ourSession = ({
+                id: 'our-session-id',
+                configuration: capturedConfig!,
+            } as unknown) as DebugSession;
+            startCallback?.(ourSession);
+
+            // Create a different session (like another project's debug)
+            const otherSession = ({
+                id: 'other-session-id',
+                configuration: { __vscodeTestSessionMarker: 'different-marker' },
+            } as unknown) as DebugSession;
+
+            // Terminate the OTHER session first - should NOT resolve our promise
+            terminateCallback?.(otherSession);
+
+            // Wait a bit to ensure it didn't resolve
+            let resolved = false;
+            const checkPromise = launchPromise.then(() => {
+                resolved = true;
+            });
+
+            await new Promise((r) => setTimeout(r, 20));
+            expect(resolved).to.be.false;
+
+            // Now terminate OUR session - should resolve
+            terminateCallback?.(ourSession);
+
+            await checkPromise;
+            expect(resolved).to.be.true;
+        });
+    });
 });
diff --git a/src/test/testing/common/managers/testConfigurationManager.unit.test.ts b/src/test/testing/common/managers/testConfigurationManager.unit.test.ts
index c8b6085e599d..1b049d4f3fbe 100644
--- a/src/test/testing/common/managers/testConfigurationManager.unit.test.ts
+++ b/src/test/testing/common/managers/testConfigurationManager.unit.test.ts
@@ -5,7 +5,7 @@
 
 import * as TypeMoq from 'typemoq';
 import { OutputChannel, Uri } from 'vscode';
-import { IInstaller, ITestOutputChannel, Product } from '../../../../client/common/types';
+import { IInstaller, ILogOutputChannel, Product } from '../../../../client/common/types';
 import { getNamesAndValues } from '../../../../client/common/utils/enum';
 import { IServiceContainer } from '../../../../client/ioc/types';
 import { UNIT_TEST_PRODUCTS } from '../../../../client/testing/common/constants';
@@ -41,7 +41,7 @@ suite('Unit Test Configuration Manager (unit)', () => {
                 const installer = TypeMoq.Mock.ofType<IInstaller>().object;
                 const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
                 serviceContainer
-                    .setup((s) => s.get(TypeMoq.It.isValue(ITestOutputChannel)))
+                    .setup((s) => s.get(TypeMoq.It.isValue(ILogOutputChannel)))
                     .returns(() => outputChannel);
                 serviceContainer
                     .setup((s) => s.get(TypeMoq.It.isValue(ITestConfigSettingsService)))
diff --git a/src/test/testing/common/testingAdapter.test.ts b/src/test/testing/common/testingAdapter.test.ts
index ec19ce00f13f..478e9dd85744 100644
--- a/src/test/testing/common/testingAdapter.test.ts
+++ b/src/test/testing/common/testingAdapter.test.ts
@@ -9,9 +9,13 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as sinon from 'sinon';
 import { PytestTestDiscoveryAdapter } from '../../../client/testing/testController/pytest/pytestDiscoveryAdapter';
-import { ITestController, ITestResultResolver } from '../../../client/testing/testController/common/types';
+import {
+    ITestController,
+    ITestResultResolver,
+    ExecutionTestPayload,
+} from '../../../client/testing/testController/common/types';
 import { IPythonExecutionFactory } from '../../../client/common/process/types';
-import { IConfigurationService, ITestOutputChannel } from '../../../client/common/types';
+import { IConfigurationService } from '../../../client/common/types';
 import { IServiceContainer } from '../../../client/ioc/types';
 import { EXTENSION_ROOT_DIR_FOR_TESTS, initialize } from '../../initialize';
 import { traceError, traceLog } from '../../../client/logging';
@@ -22,7 +26,6 @@ import { PythonResultResolver } from '../../../client/testing/testController/com
 import { TestProvider } from '../../../client/testing/types';
 import { PYTEST_PROVIDER, UNITTEST_PROVIDER } from '../../../client/testing/common/constants';
 import { IEnvironmentVariablesProvider } from '../../../client/common/variables/types';
-import { createTypeMoq } from '../../mocks/helper';
 import * as pixi from '../../../client/pythonEnvironments/common/environmentManagers/pixi';
 
 suite('End to End Tests: test adapters', () => {
@@ -32,7 +35,6 @@ suite('End to End Tests: test adapters', () => {
     let serviceContainer: IServiceContainer;
     let envVarsService: IEnvironmentVariablesProvider;
     let workspaceUri: Uri;
-    let testOutputChannel: typeMoq.IMock<ITestOutputChannel>;
     let testController: TestController;
     let getPixiStub: sinon.SinonStub;
     const unittestProvider: TestProvider = UNITTEST_PROVIDER;
@@ -116,24 +118,6 @@ suite('End to End Tests: test adapters', () => {
         envVarsService = serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
 
         // create objects that were not injected
-
-        testOutputChannel = createTypeMoq<ITestOutputChannel>();
-        testOutputChannel
-            .setup((x) => x.append(typeMoq.It.isAny()))
-            .callback((appendVal: any) => {
-                traceLog('output channel - ', appendVal.toString());
-            })
-            .returns(() => {
-                // Whatever you need to return
-            });
-        testOutputChannel
-            .setup((x) => x.appendLine(typeMoq.It.isAny()))
-            .callback((appendVal: any) => {
-                traceLog('output channel ', appendVal.toString());
-            })
-            .returns(() => {
-                // Whatever you need to return
-            });
     });
     teardown(() => {
         sinon.restore();
@@ -177,11 +161,10 @@ suite('End to End Tests: test adapters', () => {
         resultResolver = new PythonResultResolver(testController, unittestProvider, workspaceUri);
         let callCount = 0;
         // const deferredTillEOT = createTestingDeferred();
-        resultResolver._resolveDiscovery = async (payload, _token?) => {
+        resultResolver.resolveDiscovery = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             actualData = payload;
-            return Promise.resolve();
         };
 
         // set workspace to test workspace folder and set up settings
@@ -189,12 +172,7 @@ suite('End to End Tests: test adapters', () => {
         configService.getSettings(workspaceUri).testing.unittestArgs = ['-s', '.', '-p', '*test*.py'];
 
         // run unittest discovery
-        const discoveryAdapter = new UnittestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new UnittestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
 
         await discoveryAdapter.discoverTests(workspaceUri, pythonExecFactory).finally(() => {
             // verification after discovery is complete
@@ -223,23 +201,17 @@ suite('End to End Tests: test adapters', () => {
         };
         resultResolver = new PythonResultResolver(testController, unittestProvider, workspaceUri);
         let callCount = 0;
-        resultResolver._resolveDiscovery = async (payload, _token?) => {
+        resultResolver.resolveDiscovery = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             actualData = payload;
-            return Promise.resolve();
         };
 
         // set settings to work for the given workspace
         workspaceUri = Uri.parse(rootPathLargeWorkspace);
         configService.getSettings(workspaceUri).testing.unittestArgs = ['-s', '.', '-p', '*test*.py'];
         // run discovery
-        const discoveryAdapter = new UnittestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new UnittestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
 
         await discoveryAdapter.discoverTests(workspaceUri, pythonExecFactory).finally(() => {
             // 1. Check the status is "success"
@@ -268,18 +240,12 @@ suite('End to End Tests: test adapters', () => {
         workspaceUri = Uri.parse(rootPathSmallWorkspace);
         resultResolver = new PythonResultResolver(testController, pytestProvider, workspaceUri);
         let callCount = 0;
-        resultResolver._resolveDiscovery = async (payload, _token?) => {
+        resultResolver.resolveDiscovery = (payload, _token?) => {
             callCount = callCount + 1;
             actualData = payload;
-            return Promise.resolve();
         };
         // run pytest discovery
-        const discoveryAdapter = new PytestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new PytestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
 
         await discoveryAdapter.discoverTests(workspaceUri, pythonExecFactory).finally(() => {
             // verification after discovery is complete
@@ -322,19 +288,13 @@ suite('End to End Tests: test adapters', () => {
 
         resultResolver = new PythonResultResolver(testController, pytestProvider, workspaceUri);
         let callCount = 0;
-        resultResolver._resolveDiscovery = async (payload, _token?) => {
+        resultResolver.resolveDiscovery = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             actualData = payload;
-            return Promise.resolve();
         };
         // run pytest discovery
-        const discoveryAdapter = new PytestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new PytestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
         configService.getSettings(workspaceUri).testing.pytestArgs = [];
 
         await discoveryAdapter.discoverTests(workspaceUri, pythonExecFactory).finally(() => {
@@ -411,19 +371,13 @@ suite('End to End Tests: test adapters', () => {
 
         resultResolver = new PythonResultResolver(testController, pytestProvider, workspaceUri);
         let callCount = 0;
-        resultResolver._resolveDiscovery = async (payload, _token?) => {
+        resultResolver.resolveDiscovery = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             actualData = payload;
-            return Promise.resolve();
         };
         // run pytest discovery
-        const discoveryAdapter = new PytestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new PytestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
         configService.getSettings(workspaceUri).testing.pytestArgs = [];
 
         await discoveryAdapter.discoverTests(workspaceUri, pythonExecFactory).finally(() => {
@@ -487,19 +441,13 @@ suite('End to End Tests: test adapters', () => {
         };
         resultResolver = new PythonResultResolver(testController, pytestProvider, workspaceUri);
         let callCount = 0;
-        resultResolver._resolveDiscovery = async (payload, _token?) => {
+        resultResolver.resolveDiscovery = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             actualData = payload;
-            return Promise.resolve();
         };
         // run pytest discovery
-        const discoveryAdapter = new PytestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new PytestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
 
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathLargeWorkspace);
@@ -526,34 +474,30 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveExecution = async (payload, _token?) => {
+        resultResolver.resolveExecution = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             // the payloads that get to the _resolveExecution are all data and should be successful.
             try {
-                assert.strictEqual(
-                    payload.status,
-                    'success',
-                    `Expected status to be 'success', instead status is ${payload.status}`,
-                );
-                assert.ok(payload.result, 'Expected results to be present');
+                if ('status' in payload) {
+                    assert.strictEqual(
+                        payload.status,
+                        'success',
+                        `Expected status to be 'success', instead status is ${payload.status}`,
+                    );
+                    assert.ok(payload.result, 'Expected results to be present');
+                }
             } catch (err) {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
 
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathSmallWorkspace);
         configService.getSettings(workspaceUri).testing.unittestArgs = ['-s', '.', '-p', '*test*.py'];
         // run execution
-        const executionAdapter = new UnittestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new UnittestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -605,22 +549,25 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveExecution = async (payload, _token?) => {
+        resultResolver.resolveExecution = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             // the payloads that get to the _resolveExecution are all data and should be successful.
             try {
-                const validStatuses = ['subtest-success', 'subtest-failure'];
-                assert.ok(
-                    validStatuses.includes(payload.status),
-                    `Expected status to be one of ${validStatuses.join(', ')}, but instead status is ${payload.status}`,
-                );
-                assert.ok(payload.result, 'Expected results to be present');
+                if ('status' in payload) {
+                    const validStatuses = ['subtest-success', 'subtest-failure'];
+                    assert.ok(
+                        validStatuses.includes(payload.status),
+                        `Expected status to be one of ${validStatuses.join(', ')}, but instead status is ${
+                            payload.status
+                        }`,
+                    );
+                    assert.ok(payload.result, 'Expected results to be present');
+                }
             } catch (err) {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
 
         // set workspace to test workspace folder
@@ -628,12 +575,7 @@ suite('End to End Tests: test adapters', () => {
         configService.getSettings(workspaceUri).testing.unittestArgs = ['-s', '.', '-p', '*test*.py'];
 
         // run unittest execution
-        const executionAdapter = new UnittestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new UnittestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -681,34 +623,30 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveExecution = async (payload, _token?) => {
+        resultResolver.resolveExecution = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             // the payloads that get to the _resolveExecution are all data and should be successful.
             try {
-                assert.strictEqual(
-                    payload.status,
-                    'success',
-                    `Expected status to be 'success', instead status is ${payload.status}`,
-                );
-                assert.ok(payload.result, 'Expected results to be present');
+                if ('status' in payload) {
+                    assert.strictEqual(
+                        payload.status,
+                        'success',
+                        `Expected status to be 'success', instead status is ${payload.status}`,
+                    );
+                    assert.ok(payload.result, 'Expected results to be present');
+                }
             } catch (err) {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathSmallWorkspace);
         configService.getSettings(workspaceUri).testing.pytestArgs = [];
 
         // run pytest execution
-        const executionAdapter = new PytestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new PytestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -768,7 +706,7 @@ suite('End to End Tests: test adapters', () => {
     test('Unittest execution with coverage, small workspace', async () => {
         // result resolver and saved data for assertions
         resultResolver = new PythonResultResolver(testController, unittestProvider, workspaceUri);
-        resultResolver._resolveCoverage = async (payload, _token?) => {
+        resultResolver._resolveCoverage = (payload, _token?) => {
             assert.strictEqual(payload.cwd, rootPathCoverageWorkspace, 'Expected cwd to be the workspace folder');
             assert.ok(payload.result, 'Expected results to be present');
             const simpleFileCov = payload.result[`${rootPathCoverageWorkspace}/even.py`];
@@ -776,19 +714,15 @@ suite('End to End Tests: test adapters', () => {
             // since only one test was run, the other test in the same file will have missed coverage lines
             assert.strictEqual(simpleFileCov.lines_covered.length, 3, 'Expected 1 line to be covered in even.py');
             assert.strictEqual(simpleFileCov.lines_missed.length, 1, 'Expected 3 lines to be missed in even.py');
-            return Promise.resolve();
+            assert.strictEqual(simpleFileCov.executed_branches, 1, 'Expected 1 branch to be executed in even.py');
+            assert.strictEqual(simpleFileCov.total_branches, 2, 'Expected 2 branches in even.py');
         };
 
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathCoverageWorkspace);
         configService.getSettings(workspaceUri).testing.unittestArgs = ['-s', '.', '-p', '*test*.py'];
         // run execution
-        const executionAdapter = new UnittestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new UnittestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -821,7 +755,7 @@ suite('End to End Tests: test adapters', () => {
     test('pytest coverage execution, small workspace', async () => {
         // result resolver and saved data for assertions
         resultResolver = new PythonResultResolver(testController, pytestProvider, workspaceUri);
-        resultResolver._resolveCoverage = async (payload, _runInstance?) => {
+        resultResolver._resolveCoverage = (payload, _runInstance?) => {
             assert.strictEqual(payload.cwd, rootPathCoverageWorkspace, 'Expected cwd to be the workspace folder');
             assert.ok(payload.result, 'Expected results to be present');
             const simpleFileCov = payload.result[`${rootPathCoverageWorkspace}/even.py`];
@@ -829,20 +763,15 @@ suite('End to End Tests: test adapters', () => {
             // since only one test was run, the other test in the same file will have missed coverage lines
             assert.strictEqual(simpleFileCov.lines_covered.length, 3, 'Expected 1 line to be covered in even.py');
             assert.strictEqual(simpleFileCov.lines_missed.length, 1, 'Expected 3 lines to be missed in even.py');
-
-            return Promise.resolve();
+            assert.strictEqual(simpleFileCov.executed_branches, 1, 'Expected 1 branch to be executed in even.py');
+            assert.strictEqual(simpleFileCov.total_branches, 2, 'Expected 2 branches in even.py');
         };
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathCoverageWorkspace);
         configService.getSettings(workspaceUri).testing.pytestArgs = [];
 
         // run pytest execution
-        const executionAdapter = new PytestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new PytestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -878,22 +807,23 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveExecution = async (payload, _token?) => {
+        resultResolver.resolveExecution = (payload, _token?) => {
             traceLog(`resolveDiscovery ${payload}`);
             callCount = callCount + 1;
             // the payloads that get to the _resolveExecution are all data and should be successful.
             try {
-                assert.strictEqual(
-                    payload.status,
-                    'success',
-                    `Expected status to be 'success', instead status is ${payload.status}`,
-                );
-                assert.ok(payload.result, 'Expected results to be present');
+                if ('status' in payload) {
+                    assert.strictEqual(
+                        payload.status,
+                        'success',
+                        `Expected status to be 'success', instead status is ${payload.status}`,
+                    );
+                    assert.ok(payload.result, 'Expected results to be present');
+                }
             } catch (err) {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
 
         // set workspace to test workspace folder
@@ -908,12 +838,7 @@ suite('End to End Tests: test adapters', () => {
         }
 
         // run pytest execution
-        const executionAdapter = new PytestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new PytestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -950,7 +875,7 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveDiscovery = async (data, _token?) => {
+        resultResolver.resolveDiscovery = (data, _token?) => {
             // do the following asserts for each time resolveExecution is called, should be called once per test.
             callCount = callCount + 1;
             traceLog(`unittest discovery adapter seg fault error handling \n  ${JSON.stringify(data)}`);
@@ -975,19 +900,13 @@ suite('End to End Tests: test adapters', () => {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
 
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathDiscoveryErrorWorkspace);
         configService.getSettings(workspaceUri).testing.unittestArgs = ['-s', '.', '-p', '*test*.py'];
 
-        const discoveryAdapter = new UnittestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new UnittestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -1008,7 +927,7 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveDiscovery = async (data, _token?) => {
+        resultResolver.resolveDiscovery = (data, _token?) => {
             // do the following asserts for each time resolveExecution is called, should be called once per test.
             callCount = callCount + 1;
             traceLog(`add one to call count, is now ${callCount}`);
@@ -1038,15 +957,9 @@ suite('End to End Tests: test adapters', () => {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
         // run pytest discovery
-        const discoveryAdapter = new PytestTestDiscoveryAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const discoveryAdapter = new PytestTestDiscoveryAdapter(configService, resultResolver, envVarsService);
 
         // set workspace to test workspace folder
         workspaceUri = Uri.parse(rootPathDiscoveryErrorWorkspace);
@@ -1066,22 +979,24 @@ suite('End to End Tests: test adapters', () => {
         let callCount = 0;
         let failureOccurred = false;
         let failureMsg = '';
-        resultResolver._resolveExecution = async (data, _token?) => {
+        resultResolver.resolveExecution = (data, _token?) => {
             // do the following asserts for each time resolveExecution is called, should be called once per test.
             console.log(`pytest execution adapter seg fault error handling \n  ${JSON.stringify(data)}`);
             callCount = callCount + 1;
             try {
-                if (data.status === 'error') {
-                    assert.ok(data.error, "Expected errors in 'error' field");
-                } else {
-                    const indexOfTest = JSON.stringify(data.result).search('error');
-                    assert.notDeepEqual(
-                        indexOfTest,
-                        -1,
-                        'If payload status is not error then the individual tests should be marked as errors. This should occur on windows machines.',
-                    );
+                if ('status' in data) {
+                    if (data.status === 'error') {
+                        assert.ok(data.error, "Expected errors in 'error' field");
+                    } else {
+                        const indexOfTest = JSON.stringify(data.result).search('error');
+                        assert.notDeepEqual(
+                            indexOfTest,
+                            -1,
+                            'If payload status is not error then the individual tests should be marked as errors. This should occur on windows machines.',
+                        );
+                    }
+                    assert.ok(data.result, 'Expected results to be present');
                 }
-                assert.ok(data.result, 'Expected results to be present');
                 // make sure the testID is found in the results
                 const indexOfTest = JSON.stringify(data).search(
                     'test_seg_fault.py::TestSegmentationFault::test_segfault',
@@ -1091,7 +1006,6 @@ suite('End to End Tests: test adapters', () => {
                 failureMsg = err ? (err as Error).toString() : '';
                 failureOccurred = true;
             }
-            return Promise.resolve();
         };
 
         const testId = `${rootPathErrorWorkspace}/test_seg_fault.py::TestSegmentationFault::test_segfault`;
@@ -1102,12 +1016,7 @@ suite('End to End Tests: test adapters', () => {
         configService.getSettings(workspaceUri).testing.pytestArgs = [];
 
         // run pytest execution
-        const executionAdapter = new PytestTestExecutionAdapter(
-            configService,
-            testOutputChannel.object,
-            resultResolver,
-            envVarsService,
-        );
+        const executionAdapter = new PytestTestExecutionAdapter(configService, resultResolver, envVarsService);
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun
             .setup((t) => t.token)
@@ -1124,4 +1033,210 @@ suite('End to End Tests: test adapters', () => {
                 assert.strictEqual(failureOccurred, false, failureMsg);
             });
     });
+
+    test('resolveExecution performance test: validates efficient test result processing', async () => {
+        // This test validates that resolveExecution processes test results efficiently
+        // without expensive tree rebuilding or linear searching operations.
+        //
+        // The test ensures that processing many test results (like parameterized tests)
+        // remains fast and doesn't cause performance issues or stack overflow.
+
+        // ================================================================
+        // SETUP: Initialize test environment and tracking variables
+        // ================================================================
+        resultResolver = new PythonResultResolver(testController, pytestProvider, workspaceUri);
+
+        // Performance tracking variables
+        let totalCallTime = 0;
+        let callCount = 0;
+        const callTimes: number[] = [];
+        let treeRebuildCount = 0;
+        let totalSearchOperations = 0;
+
+        // Test configuration - Moderate scale to validate efficiency
+        const numTestFiles = 5; // Multiple test files
+        const testFunctionsPerFile = 10; // Test functions per file
+        const totalTestItems = numTestFiles * testFunctionsPerFile; // Total test items in mock tree
+        const numParameterizedResults = 15; // Number of parameterized test results to process
+
+        // ================================================================
+        // MOCK: Set up spies and function wrapping to track performance
+        // ================================================================
+
+        // Mock getTestCaseNodes to track expensive tree operations
+        const originalGetTestCaseNodes = require('../../../client/testing/testController/common/testItemUtilities')
+            .getTestCaseNodes;
+        const getTestCaseNodesSpy = sinon.stub().callsFake((item) => {
+            treeRebuildCount++;
+            const result = originalGetTestCaseNodes(item);
+            // Track search operations through tree items
+            // Safely handle undefined results
+            if (result && Array.isArray(result)) {
+                totalSearchOperations += result.length;
+            }
+            return result || []; // Return empty array if undefined
+        });
+
+        // Replace the real function with our spy
+        const testItemUtilities = require('../../../client/testing/testController/common/testItemUtilities');
+        testItemUtilities.getTestCaseNodes = getTestCaseNodesSpy;
+
+        // Stub isTestItemValid to always return true for performance test
+        // This prevents expensive tree searches during validation
+        const testItemIndexStub = sinon.stub((resultResolver as any).testItemIndex, 'isTestItemValid').returns(true);
+
+        // Wrap the _resolveExecution function to measure performance
+        const original_resolveExecution = resultResolver.resolveExecution.bind(resultResolver);
+        resultResolver.resolveExecution = (payload, runInstance) => {
+            const startTime = performance.now();
+            callCount++;
+
+            // Call the actual implementation
+            original_resolveExecution(payload, runInstance);
+
+            const endTime = performance.now();
+            const callTime = endTime - startTime;
+            callTimes.push(callTime);
+            totalCallTime += callTime;
+        };
+
+        // ================================================================
+        // SETUP: Create test data that simulates realistic test scenarios
+        // ================================================================
+
+        // Create a mock TestController with the methods we need
+        const mockTestController = {
+            items: new Map(),
+            createTestItem: (id: string, label: string, uri?: Uri) => {
+                const childrenMap = new Map();
+                // Add forEach method to children map to simulate TestItemCollection
+                (childrenMap as any).forEach = function (callback: (item: any) => void) {
+                    Map.prototype.forEach.call(this, callback);
+                };
+
+                const mockTestItem = {
+                    id,
+                    label,
+                    uri,
+                    children: childrenMap,
+                    parent: undefined,
+                    canResolveChildren: false,
+                    tags: [{ id: 'python-run' }, { id: 'python-debug' }],
+                };
+                return mockTestItem;
+            },
+            // Add a forEach method to simulate the problematic iteration
+            forEach: function (callback: (item: any) => void) {
+                this.items.forEach(callback);
+            },
+        }; // Replace the testController in our resolver
+        (resultResolver as any).testController = mockTestController;
+
+        // Create test controller with many test items (simulates real workspace)
+        for (let i = 0; i < numTestFiles; i++) {
+            const testItem = mockTestController.createTestItem(
+                `test_file_${i}`,
+                `Test File ${i}`,
+                Uri.file(`/test_${i}.py`),
+            );
+            mockTestController.items.set(`test_file_${i}`, testItem);
+
+            // Add child test items to each file
+            for (let j = 0; j < testFunctionsPerFile; j++) {
+                const childItem = mockTestController.createTestItem(
+                    `test_${i}_${j}`,
+                    `test_method_${j}`,
+                    Uri.file(`/test_${i}.py`),
+                );
+                testItem.children.set(`test_${i}_${j}`, childItem);
+
+                // Set up the ID mappings that the resolver uses
+                resultResolver.runIdToTestItem.set(`test_${i}_${j}`, childItem as any);
+                resultResolver.runIdToVSid.set(`test_${i}_${j}`, `test_${i}_${j}`);
+                resultResolver.vsIdToRunId.set(`test_${i}_${j}`, `test_${i}_${j}`);
+            }
+        } // Create payload with multiple test results (simulates real test execution)
+        const testResults: Record<string, any> = {};
+        for (let i = 0; i < numParameterizedResults; i++) {
+            // Use test IDs that actually exist in our mock setup (test_0_0 through test_0_9)
+            testResults[`test_0_${i % testFunctionsPerFile}`] = {
+                test: `test_method[${i}]`,
+                outcome: 'success',
+                message: null,
+                traceback: null,
+                subtest: null,
+            };
+        }
+
+        const payload: ExecutionTestPayload = {
+            cwd: '/test',
+            status: 'success' as const,
+            error: '',
+            result: testResults,
+        };
+
+        const mockRunInstance = {
+            passed: sinon.stub(),
+            failed: sinon.stub(),
+            errored: sinon.stub(),
+            skipped: sinon.stub(),
+        };
+
+        // ================================================================
+        // EXECUTION: Run the performance test
+        // ================================================================
+
+        const overallStartTime = performance.now();
+
+        // Run the resolveExecution function with test data
+        await resultResolver.resolveExecution(payload, mockRunInstance as any);
+
+        const overallEndTime = performance.now();
+        const totalTime = overallEndTime - overallStartTime;
+
+        // ================================================================
+        // CLEANUP: Restore original functions
+        // ================================================================
+        testItemUtilities.getTestCaseNodes = originalGetTestCaseNodes;
+        testItemIndexStub.restore();
+
+        // ================================================================
+        // ASSERT: Verify efficient performance characteristics
+        // ================================================================
+        console.log(`\n=== PERFORMANCE RESULTS ===`);
+        console.log(
+            `Test setup: ${numTestFiles} files × ${testFunctionsPerFile} test functions = ${totalTestItems} total items`,
+        );
+        console.log(`Total execution time: ${totalTime.toFixed(2)}ms`);
+        console.log(`Tree operations performed: ${treeRebuildCount}`);
+        console.log(`Search operations: ${totalSearchOperations}`);
+        console.log(`Average time per call: ${(totalCallTime / callCount).toFixed(2)}ms`);
+        console.log(`Results processed: ${numParameterizedResults}`);
+
+        // Basic function call verification
+        assert.strictEqual(callCount, 1, 'Expected resolveExecution to be called once');
+
+        // EFFICIENCY VERIFICATION: Ensure minimal expensive operations
+        assert.strictEqual(
+            treeRebuildCount,
+            0,
+            'Expected ZERO tree rebuilds - efficient implementation should use cached lookups',
+        );
+
+        assert.strictEqual(
+            totalSearchOperations,
+            0,
+            'Expected ZERO linear search operations - efficient implementation should use direct lookups',
+        );
+
+        // Performance threshold verification - should be fast
+        assert.ok(totalTime < 100, `Function should complete quickly, took ${totalTime}ms (should be under 100ms)`);
+
+        // Scalability check - time should not grow significantly with more results
+        const timePerResult = totalTime / numParameterizedResults;
+        assert.ok(
+            timePerResult < 10,
+            `Time per result should be minimal: ${timePerResult.toFixed(2)}ms per result (should be under 10ms)`,
+        );
+    });
 });
diff --git a/src/test/testing/configuration.unit.test.ts b/src/test/testing/configuration.unit.test.ts
index 6682abf019b8..e259587ecccd 100644
--- a/src/test/testing/configuration.unit.test.ts
+++ b/src/test/testing/configuration.unit.test.ts
@@ -10,7 +10,7 @@ import { IApplicationShell, ICommandManager, IWorkspaceService } from '../../cli
 import {
     IConfigurationService,
     IInstaller,
-    ITestOutputChannel,
+    ILogOutputChannel,
     IPythonSettings,
     Product,
 } from '../../client/common/types';
@@ -25,7 +25,7 @@ import {
     ITestsHelper,
 } from '../../client/testing/common/types';
 import { ITestingSettings } from '../../client/testing/configuration/types';
-import { NONE_SELECTED, UnitTestConfigurationService } from '../../client/testing/configuration';
+import { UnitTestConfigurationService } from '../../client/testing/configuration';
 
 suite('Unit Tests - ConfigurationService', () => {
     UNIT_TEST_PRODUCTS.forEach((product) => {
@@ -61,7 +61,7 @@ suite('Unit Tests - ConfigurationService', () => {
                 configurationService.setup((c) => c.getSettings(workspaceUri)).returns(() => pythonSettings.object);
 
                 serviceContainer
-                    .setup((c) => c.get(typeMoq.It.isValue(ITestOutputChannel)))
+                    .setup((c) => c.get(typeMoq.It.isValue(ILogOutputChannel)))
                     .returns(() => outputChannel.object);
                 serviceContainer.setup((c) => c.get(typeMoq.It.isValue(IInstaller))).returns(() => installer.object);
                 serviceContainer
@@ -259,198 +259,6 @@ suite('Unit Tests - ConfigurationService', () => {
                 enabled = true;
                 expect(testConfigService.target.hasConfiguredTests(workspaceUri)).to.equal(true);
             });
-            test('Prompt to enable a test if a test framework is not enabled', async () => {
-                unitTestSettings.setup((u) => u.pytestEnabled).returns(() => false);
-                unitTestSettings.setup((u) => u.unittestEnabled).returns(() => false);
-
-                appShell
-                    .setup((s) => s.showInformationMessage(typeMoq.It.isAny(), typeMoq.It.isAny()))
-                    .returns(() => Promise.resolve(undefined))
-                    .verifiable(typeMoq.Times.once());
-
-                let exceptionThrown = false;
-                try {
-                    await testConfigService.target.displayTestFrameworkError(workspaceUri);
-                } catch (exc) {
-                    if (exc !== NONE_SELECTED) {
-                        throw exc;
-                    }
-                    exceptionThrown = true;
-                }
-
-                expect(exceptionThrown).to.be.equal(true, 'Exception not thrown');
-                appShell.verifyAll();
-            });
-            test('Prompt to select a test if a test framework is not enabled', async () => {
-                unitTestSettings.setup((u) => u.pytestEnabled).returns(() => false);
-                unitTestSettings.setup((u) => u.unittestEnabled).returns(() => false);
-
-                appShell
-                    .setup((s) => s.showInformationMessage(typeMoq.It.isAny(), typeMoq.It.isAny()))
-                    .returns((_msg, option) => Promise.resolve(option))
-                    .verifiable(typeMoq.Times.once());
-
-                let exceptionThrown = false;
-                let selectTestRunnerInvoked = false;
-                try {
-                    testConfigService.callBase = false;
-                    testConfigService
-                        .setup((t) => t.selectTestRunner(typeMoq.It.isAny()))
-                        .returns(() => {
-                            selectTestRunnerInvoked = true;
-                            return Promise.resolve(undefined);
-                        });
-                    await testConfigService.target.displayTestFrameworkError(workspaceUri);
-                } catch (exc) {
-                    if (exc !== NONE_SELECTED) {
-                        throw exc;
-                    }
-                    exceptionThrown = true;
-                }
-
-                expect(selectTestRunnerInvoked).to.be.equal(true, 'Method not invoked');
-                expect(exceptionThrown).to.be.equal(true, 'Exception not thrown');
-                appShell.verifyAll();
-            });
-            test('Configure selected test framework and disable others', async () => {
-                unitTestSettings.setup((u) => u.pytestEnabled).returns(() => false);
-                unitTestSettings.setup((u) => u.unittestEnabled).returns(() => false);
-
-                const workspaceConfig = typeMoq.Mock.ofType<WorkspaceConfiguration>(
-                    undefined,
-                    typeMoq.MockBehavior.Strict,
-                );
-                workspaceConfig
-                    .setup((w) => w.get(typeMoq.It.isAny()))
-                    .returns(() => true)
-                    .verifiable(typeMoq.Times.once());
-                workspaceService
-                    .setup((w) => w.getConfiguration(typeMoq.It.isValue('python'), workspaceUri))
-                    .returns(() => workspaceConfig.object)
-                    .verifiable(typeMoq.Times.once());
-
-                appShell
-                    .setup((s) => s.showInformationMessage(typeMoq.It.isAny(), typeMoq.It.isAny()))
-                    .returns((_msg, option) => Promise.resolve(option))
-                    .verifiable(typeMoq.Times.once());
-
-                let selectTestRunnerInvoked = false;
-                testConfigService.callBase = false;
-                testConfigService
-                    .setup((t) => t.selectTestRunner(typeMoq.It.isAny()))
-                    .returns(() => {
-                        selectTestRunnerInvoked = true;
-                        return Promise.resolve(product);
-                    });
-
-                const configMgr = typeMoq.Mock.ofType<ITestConfigurationManager>(
-                    undefined,
-                    typeMoq.MockBehavior.Strict,
-                );
-                factory
-                    .setup((f) =>
-                        f.create(typeMoq.It.isValue(workspaceUri), typeMoq.It.isValue(product), typeMoq.It.isAny()),
-                    )
-                    .returns(() => configMgr.object)
-                    .verifiable(typeMoq.Times.once());
-
-                configMgr
-                    .setup((c) => c.configure(typeMoq.It.isValue(workspaceUri)))
-                    .returns(() => Promise.resolve())
-                    .verifiable(typeMoq.Times.once());
-                configMgr
-                    .setup((c) => c.enable())
-                    .returns(() => Promise.resolve())
-                    .verifiable(typeMoq.Times.once());
-
-                await testConfigService.target.displayTestFrameworkError(workspaceUri);
-
-                expect(selectTestRunnerInvoked).to.be.equal(true, 'Select Test Runner not invoked');
-                appShell.verifyAll();
-                factory.verifyAll();
-                configMgr.verifyAll();
-                workspaceConfig.verifyAll();
-            });
-            test('If more than one test framework is enabled, then prompt to select a test framework', async () => {
-                unitTestSettings.setup((u) => u.pytestEnabled).returns(() => true);
-                unitTestSettings.setup((u) => u.unittestEnabled).returns(() => true);
-
-                appShell
-                    .setup((s) => s.showInformationMessage(typeMoq.It.isAny(), typeMoq.It.isAny()))
-                    .returns(() => Promise.resolve(undefined))
-                    .verifiable(typeMoq.Times.never());
-                appShell
-                    .setup((s) => s.showQuickPick(typeMoq.It.isAny(), typeMoq.It.isAny()))
-                    .returns(() => Promise.resolve(undefined))
-                    .verifiable(typeMoq.Times.once());
-
-                let exceptionThrown = false;
-                try {
-                    await testConfigService.target.displayTestFrameworkError(workspaceUri);
-                } catch (exc) {
-                    if (exc !== NONE_SELECTED) {
-                        throw exc;
-                    }
-                    exceptionThrown = true;
-                }
-
-                expect(exceptionThrown).to.be.equal(true, 'Exception not thrown');
-                appShell.verifyAll();
-            });
-            test('If more than one test framework is enabled, then prompt to select a test framework and enable test, but do not configure', async () => {
-                unitTestSettings.setup((u) => u.pytestEnabled).returns(() => true);
-                unitTestSettings.setup((u) => u.unittestEnabled).returns(() => true);
-
-                appShell
-                    .setup((s) => s.showInformationMessage(typeMoq.It.isAny(), typeMoq.It.isAny()))
-                    .returns((_msg, option) => Promise.resolve(option))
-                    .verifiable(typeMoq.Times.never());
-
-                let selectTestRunnerInvoked = false;
-                testConfigService.callBase = false;
-                testConfigService
-                    .setup((t) => t.selectTestRunner(typeMoq.It.isAny()))
-                    .returns(() => {
-                        selectTestRunnerInvoked = true;
-                        return Promise.resolve(product);
-                    });
-
-                let enableTestInvoked = false;
-                testConfigService
-                    .setup((t) => t.enableTest(typeMoq.It.isValue(workspaceUri), typeMoq.It.isValue(product)))
-                    .returns(() => {
-                        enableTestInvoked = true;
-                        return Promise.resolve();
-                    });
-
-                const configMgr = typeMoq.Mock.ofType<ITestConfigurationManager>(
-                    undefined,
-                    typeMoq.MockBehavior.Strict,
-                );
-                factory
-                    .setup((f) =>
-                        f.create(typeMoq.It.isValue(workspaceUri), typeMoq.It.isValue(product), typeMoq.It.isAny()),
-                    )
-                    .returns(() => configMgr.object)
-                    .verifiable(typeMoq.Times.once());
-
-                configMgr
-                    .setup((c) => c.configure(typeMoq.It.isValue(workspaceUri)))
-                    .returns(() => Promise.resolve())
-                    .verifiable(typeMoq.Times.never());
-                configMgr
-                    .setup((c) => c.enable())
-                    .returns(() => Promise.resolve())
-                    .verifiable(typeMoq.Times.once());
-
-                await testConfigService.target.displayTestFrameworkError(workspaceUri);
-
-                expect(selectTestRunnerInvoked).to.be.equal(true, 'Select Test Runner not invoked');
-                expect(enableTestInvoked).to.be.equal(false, 'Enable Test is invoked');
-                factory.verifyAll();
-                appShell.verifyAll();
-                configMgr.verifyAll();
-            });
 
             test('Prompt to enable and configure selected test framework', async () => {
                 unitTestSettings.setup((u) => u.pytestEnabled).returns(() => false);
diff --git a/src/test/testing/configuration/pytestInstallationHelper.unit.test.ts b/src/test/testing/configuration/pytestInstallationHelper.unit.test.ts
new file mode 100644
index 000000000000..d7a1313df591
--- /dev/null
+++ b/src/test/testing/configuration/pytestInstallationHelper.unit.test.ts
@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Uri } from 'vscode';
+import * as TypeMoq from 'typemoq';
+import { IApplicationShell } from '../../../client/common/application/types';
+import { PytestInstallationHelper } from '../../../client/testing/configuration/pytestInstallationHelper';
+import * as envExtApi from '../../../client/envExt/api.internal';
+
+suite('PytestInstallationHelper', () => {
+    let appShell: TypeMoq.IMock<IApplicationShell>;
+    let helper: PytestInstallationHelper;
+    let useEnvExtensionStub: sinon.SinonStub;
+    let getEnvExtApiStub: sinon.SinonStub;
+    let getEnvironmentStub: sinon.SinonStub;
+
+    const workspaceUri = Uri.file('/test/workspace');
+
+    setup(() => {
+        appShell = TypeMoq.Mock.ofType<IApplicationShell>();
+        helper = new PytestInstallationHelper(appShell.object);
+
+        useEnvExtensionStub = sinon.stub(envExtApi, 'useEnvExtension');
+        getEnvExtApiStub = sinon.stub(envExtApi, 'getEnvExtApi');
+        getEnvironmentStub = sinon.stub(envExtApi, 'getEnvironment');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('promptToInstallPytest should return false if user selects ignore', async () => {
+        appShell
+            .setup((a) =>
+                a.showInformationMessage(
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                ),
+            )
+            .returns(() => Promise.resolve('Ignore'))
+            .verifiable(TypeMoq.Times.once());
+
+        const result = await helper.promptToInstallPytest(workspaceUri);
+
+        expect(result).to.be.false;
+        appShell.verifyAll();
+    });
+
+    test('promptToInstallPytest should return false if user cancels', async () => {
+        appShell
+            .setup((a) =>
+                a.showInformationMessage(
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                ),
+            )
+            .returns(() => Promise.resolve(undefined))
+            .verifiable(TypeMoq.Times.once());
+
+        const result = await helper.promptToInstallPytest(workspaceUri);
+
+        expect(result).to.be.false;
+        appShell.verifyAll();
+    });
+
+    test('isEnvExtensionAvailable should return result from useEnvExtension', () => {
+        useEnvExtensionStub.returns(true);
+
+        const result = helper.isEnvExtensionAvailable();
+
+        expect(result).to.be.true;
+        expect(useEnvExtensionStub.calledOnce).to.be.true;
+    });
+
+    test('promptToInstallPytest should return false if env extension not available', async () => {
+        useEnvExtensionStub.returns(false);
+
+        appShell
+            .setup((a) =>
+                a.showInformationMessage(
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                ),
+            )
+            .returns(() => Promise.resolve('Install pytest'))
+            .verifiable(TypeMoq.Times.once());
+
+        const result = await helper.promptToInstallPytest(workspaceUri);
+
+        expect(result).to.be.false;
+        appShell.verifyAll();
+    });
+
+    test('promptToInstallPytest should attempt installation when env extension is available', async () => {
+        useEnvExtensionStub.returns(true);
+
+        const mockEnvironment = { envId: { id: 'test-env', managerId: 'test-manager' } };
+        const mockEnvExtApi = {
+            managePackages: sinon.stub().resolves(),
+        };
+
+        getEnvExtApiStub.resolves(mockEnvExtApi);
+        getEnvironmentStub.resolves(mockEnvironment);
+
+        appShell
+            .setup((a) =>
+                a.showInformationMessage(
+                    TypeMoq.It.is((msg: string) => msg.includes('pytest selected but not installed')),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                    TypeMoq.It.isAny(),
+                ),
+            )
+            .returns(() => Promise.resolve('Install pytest'))
+            .verifiable(TypeMoq.Times.once());
+
+        const result = await helper.promptToInstallPytest(workspaceUri);
+
+        expect(result).to.be.true;
+        expect(mockEnvExtApi.managePackages.calledOnceWithExactly(mockEnvironment, { install: ['pytest'] })).to.be.true;
+        appShell.verifyAll();
+    });
+});
diff --git a/src/test/testing/configurationFactory.unit.test.ts b/src/test/testing/configurationFactory.unit.test.ts
index 0813e3f4aae1..493dfcc00b95 100644
--- a/src/test/testing/configurationFactory.unit.test.ts
+++ b/src/test/testing/configurationFactory.unit.test.ts
@@ -7,7 +7,7 @@ import { expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import * as typeMoq from 'typemoq';
 import { OutputChannel, Uri } from 'vscode';
-import { IInstaller, ITestOutputChannel, Product } from '../../client/common/types';
+import { IInstaller, ILogOutputChannel, Product } from '../../client/common/types';
 import { IServiceContainer } from '../../client/ioc/types';
 import { ITestConfigSettingsService, ITestConfigurationManagerFactory } from '../../client/testing/common/types';
 import { TestConfigurationManagerFactory } from '../../client/testing/configurationFactory';
@@ -24,9 +24,7 @@ suite('Unit Tests - ConfigurationManagerFactory', () => {
         const installer = typeMoq.Mock.ofType<IInstaller>();
         const testConfigService = typeMoq.Mock.ofType<ITestConfigSettingsService>();
 
-        serviceContainer
-            .setup((c) => c.get(typeMoq.It.isValue(ITestOutputChannel)))
-            .returns(() => outputChannel.object);
+        serviceContainer.setup((c) => c.get(typeMoq.It.isValue(ILogOutputChannel))).returns(() => outputChannel.object);
         serviceContainer.setup((c) => c.get(typeMoq.It.isValue(IInstaller))).returns(() => installer.object);
         serviceContainer
             .setup((c) => c.get(typeMoq.It.isValue(ITestConfigSettingsService)))
diff --git a/src/test/testing/testController/common/buildErrorNodeOptions.unit.test.ts b/src/test/testing/testController/common/buildErrorNodeOptions.unit.test.ts
new file mode 100644
index 000000000000..643ea17903e6
--- /dev/null
+++ b/src/test/testing/testController/common/buildErrorNodeOptions.unit.test.ts
@@ -0,0 +1,111 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import { Uri } from 'vscode';
+import { buildErrorNodeOptions } from '../../../../client/testing/testController/common/utils';
+
+suite('buildErrorNodeOptions - missing module detection', () => {
+    const workspaceUri = Uri.file('/test/workspace');
+
+    test('Should detect pytest ModuleNotFoundError and show missing module label', () => {
+        const errorMessage =
+            'Traceback (most recent call last):\n  File "<string>", line 1, in <module>\n    import pytest\nModuleNotFoundError: No module named \'pytest\'';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'pytest');
+
+        expect(result.label).to.equal('Missing Module: pytest [workspace]');
+        expect(result.error).to.equal(
+            "The module 'pytest' is not installed in the selected Python environment. Please install it to enable test discovery.",
+        );
+    });
+
+    test('Should detect pytest ImportError and show missing module label', () => {
+        const errorMessage = 'ImportError: No module named pytest';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'pytest');
+
+        expect(result.label).to.equal('Missing Module: pytest [workspace]');
+        expect(result.error).to.equal(
+            "The module 'pytest' is not installed in the selected Python environment. Please install it to enable test discovery.",
+        );
+    });
+
+    test('Should detect other missing modules and show module name in label', () => {
+        const errorMessage =
+            "bob\\test_bob.py:3: in <module>\n    import requests\nE   ModuleNotFoundError: No module named 'requests'\n=========================== short test summary info";
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'pytest');
+
+        expect(result.label).to.equal('Missing Module: requests [workspace]');
+        expect(result.error).to.equal(
+            "The module 'requests' is not installed in the selected Python environment. Please install it to enable test discovery.",
+        );
+    });
+
+    test('Should detect missing module with double quotes', () => {
+        const errorMessage = 'ModuleNotFoundError: No module named "numpy"';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'pytest');
+
+        expect(result.label).to.equal('Missing Module: numpy [workspace]');
+        expect(result.error).to.equal(
+            "The module 'numpy' is not installed in the selected Python environment. Please install it to enable test discovery.",
+        );
+    });
+
+    test('Should use generic error for non-module-related errors', () => {
+        const errorMessage = 'Some other error occurred';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'pytest');
+
+        expect(result.label).to.equal('pytest Discovery Error [workspace]');
+        expect(result.error).to.equal('Some other error occurred');
+    });
+
+    test('Should detect missing module for unittest errors', () => {
+        const errorMessage = "ModuleNotFoundError: No module named 'pandas'";
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'unittest');
+
+        expect(result.label).to.equal('Missing Module: pandas [workspace]');
+        expect(result.error).to.equal(
+            "The module 'pandas' is not installed in the selected Python environment. Please install it to enable test discovery.",
+        );
+    });
+
+    test('Should use generic error for unittest non-module errors', () => {
+        const errorMessage = 'Some other error occurred';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'unittest');
+
+        expect(result.label).to.equal('Unittest Discovery Error [workspace]');
+        expect(result.error).to.equal('Some other error occurred');
+    });
+
+    test('Should use project name in label when projectName is provided', () => {
+        const errorMessage = 'Some error occurred';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'unittest', 'my-project');
+
+        expect(result.label).to.equal('Unittest Discovery Error [my-project]');
+        expect(result.error).to.equal('Some error occurred');
+    });
+
+    test('Should use project name in label for pytest when projectName is provided', () => {
+        const errorMessage = 'Some error occurred';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'pytest', 'ada');
+
+        expect(result.label).to.equal('pytest Discovery Error [ada]');
+        expect(result.error).to.equal('Some error occurred');
+    });
+
+    test('Should use folder name when projectName is undefined', () => {
+        const errorMessage = 'Some error occurred';
+
+        const result = buildErrorNodeOptions(workspaceUri, errorMessage, 'unittest', undefined);
+
+        expect(result.label).to.equal('Unittest Discovery Error [workspace]');
+    });
+});
diff --git a/src/test/testing/testController/common/projectTestExecution.unit.test.ts b/src/test/testing/testController/common/projectTestExecution.unit.test.ts
new file mode 100644
index 000000000000..1cce2d1a8ce0
--- /dev/null
+++ b/src/test/testing/testController/common/projectTestExecution.unit.test.ts
@@ -0,0 +1,740 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as typemoq from 'typemoq';
+import {
+    CancellationToken,
+    CancellationTokenSource,
+    TestRun,
+    TestRunProfile,
+    TestRunProfileKind,
+    TestRunRequest,
+    Uri,
+} from 'vscode';
+import {
+    createMockDependencies,
+    createMockProjectAdapter,
+    createMockTestItem,
+    createMockTestItemWithoutUri,
+    createMockTestRun,
+} from '../testMocks';
+import {
+    executeTestsForProject,
+    executeTestsForProjects,
+    findProjectForTestItem,
+    getTestCaseNodesRecursive,
+    groupTestItemsByProject,
+    setupCoverageForProjects,
+} from '../../../../client/testing/testController/common/projectTestExecution';
+import * as telemetry from '../../../../client/telemetry';
+import * as envExtApi from '../../../../client/envExt/api.internal';
+
+suite('Project Test Execution', () => {
+    let sandbox: sinon.SinonSandbox;
+    let useEnvExtensionStub: sinon.SinonStub;
+
+    setup(() => {
+        sandbox = sinon.createSandbox();
+        // Default to disabled env extension for path-based fallback tests
+        useEnvExtensionStub = sandbox.stub(envExtApi, 'useEnvExtension').returns(false);
+    });
+
+    teardown(() => {
+        sandbox.restore();
+    });
+
+    // ===== findProjectForTestItem Tests =====
+
+    suite('findProjectForTestItem', () => {
+        test('should return undefined when test item has no URI', async () => {
+            // Mock
+            const item = createMockTestItemWithoutUri('test1');
+            const projects = [createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' })];
+
+            // Run
+            const result = await findProjectForTestItem(item, projects);
+
+            // Assert
+            expect(result).to.be.undefined;
+        });
+
+        test('should return matching project when item path is within project directory', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/workspace/proj/tests/test_file.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await findProjectForTestItem(item, [project]);
+
+            // Assert
+            expect(result).to.equal(project);
+        });
+
+        test('should return undefined when item path is outside all project directories', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/other/path/test.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await findProjectForTestItem(item, [project]);
+
+            // Assert
+            expect(result).to.be.undefined;
+        });
+
+        test('should return most specific (deepest) project when nested projects exist', async () => {
+            // Mock - parent and child project with overlapping paths
+            const item = createMockTestItem('test1', '/workspace/parent/child/tests/test.py');
+            const parentProject = createMockProjectAdapter({ projectPath: '/workspace/parent', projectName: 'parent' });
+            const childProject = createMockProjectAdapter({
+                projectPath: '/workspace/parent/child',
+                projectName: 'child',
+            });
+
+            // Run
+            const result = await findProjectForTestItem(item, [parentProject, childProject]);
+
+            // Assert - should match child (longer path) not parent
+            expect(result).to.equal(childProject);
+        });
+
+        test('should return most specific project regardless of input order', async () => {
+            // Mock - same as above but different order
+            const item = createMockTestItem('test1', '/workspace/parent/child/tests/test.py');
+            const parentProject = createMockProjectAdapter({ projectPath: '/workspace/parent', projectName: 'parent' });
+            const childProject = createMockProjectAdapter({
+                projectPath: '/workspace/parent/child',
+                projectName: 'child',
+            });
+
+            // Run - pass child first, then parent
+            const result = await findProjectForTestItem(item, [childProject, parentProject]);
+
+            // Assert - order shouldn't affect result
+            expect(result).to.equal(childProject);
+        });
+
+        test('should match item at project root level', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/workspace/proj/test.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await findProjectForTestItem(item, [project]);
+
+            // Assert
+            expect(result).to.equal(project);
+        });
+
+        test('should use env extension API when available', async () => {
+            // Enable env extension
+            useEnvExtensionStub.returns(true);
+
+            // Mock the env extension API
+            const item = createMockTestItem('test1', '/workspace/proj/tests/test_file.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            const mockEnvApi = {
+                getPythonProject: sandbox.stub().returns({ uri: project.projectUri }),
+            };
+            sandbox.stub(envExtApi, 'getEnvExtApi').resolves(mockEnvApi as any);
+
+            // Run
+            const result = await findProjectForTestItem(item, [project]);
+
+            // Assert
+            expect(result).to.equal(project);
+            expect(mockEnvApi.getPythonProject.calledOnceWith(item.uri)).to.be.true;
+        });
+
+        test('should fall back to path matching when env extension API is unavailable', async () => {
+            // Env extension enabled but throws
+            useEnvExtensionStub.returns(true);
+            sandbox.stub(envExtApi, 'getEnvExtApi').rejects(new Error('API unavailable'));
+
+            // Mock
+            const item = createMockTestItem('test1', '/workspace/proj/tests/test_file.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await findProjectForTestItem(item, [project]);
+
+            // Assert - should still work via fallback
+            expect(result).to.equal(project);
+        });
+    });
+
+    // ===== groupTestItemsByProject Tests =====
+
+    suite('groupTestItemsByProject', () => {
+        test('should group single test item to its matching project', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/workspace/proj/test.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await groupTestItemsByProject([item], [project]);
+
+            // Assert
+            expect(result.size).to.equal(1);
+            const entry = Array.from(result.values())[0];
+            expect(entry.project).to.equal(project);
+            expect(entry.items).to.deep.equal([item]);
+        });
+
+        test('should aggregate multiple items belonging to same project', async () => {
+            // Mock
+            const item1 = createMockTestItem('test1', '/workspace/proj/tests/test1.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj/tests/test2.py');
+            const item3 = createMockTestItem('test3', '/workspace/proj/test3.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await groupTestItemsByProject([item1, item2, item3], [project]);
+
+            // Assert - use Set for order-agnostic comparison
+            expect(result.size).to.equal(1);
+            const entry = Array.from(result.values())[0];
+            expect(entry.items).to.have.length(3);
+            expect(new Set(entry.items)).to.deep.equal(new Set([item1, item2, item3]));
+        });
+
+        test('should separate items into groups by their owning project', async () => {
+            // Mock
+            const item1 = createMockTestItem('test1', '/workspace/proj1/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj2/test.py');
+            const item3 = createMockTestItem('test3', '/workspace/proj1/other_test.py');
+            const proj1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const proj2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+
+            // Run
+            const result = await groupTestItemsByProject([item1, item2, item3], [proj1, proj2]);
+
+            // Assert - use Set for order-agnostic comparison
+            expect(result.size).to.equal(2);
+            const proj1Entry = result.get(proj1.projectUri.toString());
+            const proj2Entry = result.get(proj2.projectUri.toString());
+            expect(proj1Entry?.items).to.have.length(2);
+            expect(new Set(proj1Entry?.items)).to.deep.equal(new Set([item1, item3]));
+            expect(proj2Entry?.items).to.deep.equal([item2]);
+        });
+
+        test('should return empty map when no test items provided', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await groupTestItemsByProject([], [project]);
+
+            // Assert
+            expect(result.size).to.equal(0);
+        });
+
+        test('should exclude items that do not match any project path', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/other/path/test.py');
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+
+            // Run
+            const result = await groupTestItemsByProject([item], [project]);
+
+            // Assert
+            expect(result.size).to.equal(0);
+        });
+
+        test('should assign item to most specific (deepest) project for nested paths', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/workspace/parent/child/test.py');
+            const parentProject = createMockProjectAdapter({ projectPath: '/workspace/parent', projectName: 'parent' });
+            const childProject = createMockProjectAdapter({
+                projectPath: '/workspace/parent/child',
+                projectName: 'child',
+            });
+
+            // Run
+            const result = await groupTestItemsByProject([item], [parentProject, childProject]);
+
+            // Assert
+            expect(result.size).to.equal(1);
+            const entry = result.get(childProject.projectUri.toString());
+            expect(entry?.project).to.equal(childProject);
+            expect(entry?.items).to.deep.equal([item]);
+        });
+
+        test('should omit projects that have no matching test items', async () => {
+            // Mock
+            const item = createMockTestItem('test1', '/workspace/proj1/test.py');
+            const proj1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const proj2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+
+            // Run
+            const result = await groupTestItemsByProject([item], [proj1, proj2]);
+
+            // Assert
+            expect(result.size).to.equal(1);
+            expect(result.has(proj1.projectUri.toString())).to.be.true;
+            expect(result.has(proj2.projectUri.toString())).to.be.false;
+        });
+    });
+
+    // ===== getTestCaseNodesRecursive Tests =====
+
+    suite('getTestCaseNodesRecursive', () => {
+        test('should return single item when it is a leaf node with no children', () => {
+            // Mock
+            const item = createMockTestItem('test_func', '/test.py');
+
+            // Run
+            const result = getTestCaseNodesRecursive(item);
+
+            // Assert
+            expect(result).to.deep.equal([item]);
+        });
+
+        test('should return all leaf nodes from single-level nested structure', () => {
+            // Mock
+            const leaf1 = createMockTestItem('test_method1', '/test.py');
+            const leaf2 = createMockTestItem('test_method2', '/test.py');
+            const classItem = createMockTestItem('TestClass', '/test.py', [leaf1, leaf2]);
+
+            // Run
+            const result = getTestCaseNodesRecursive(classItem);
+
+            // Assert - use Set for order-agnostic comparison
+            expect(result).to.have.length(2);
+            expect(new Set(result)).to.deep.equal(new Set([leaf1, leaf2]));
+        });
+
+        test('should traverse deeply nested structure to find all leaf nodes', () => {
+            // Mock - 3 levels deep: file → class → inner class → test
+            const leaf1 = createMockTestItem('test1', '/test.py');
+            const leaf2 = createMockTestItem('test2', '/test.py');
+            const innerClass = createMockTestItem('InnerClass', '/test.py', [leaf2]);
+            const outerClass = createMockTestItem('OuterClass', '/test.py', [leaf1, innerClass]);
+            const fileItem = createMockTestItem('test_file.py', '/test.py', [outerClass]);
+
+            // Run
+            const result = getTestCaseNodesRecursive(fileItem);
+
+            // Assert - use Set for order-agnostic comparison
+            expect(result).to.have.length(2);
+            expect(new Set(result)).to.deep.equal(new Set([leaf1, leaf2]));
+        });
+
+        test('should collect leaves from multiple sibling branches', () => {
+            // Mock - multiple test classes at same level
+            const leaf1 = createMockTestItem('test1', '/test.py');
+            const leaf2 = createMockTestItem('test2', '/test.py');
+            const leaf3 = createMockTestItem('test3', '/test.py');
+            const class1 = createMockTestItem('Class1', '/test.py', [leaf1]);
+            const class2 = createMockTestItem('Class2', '/test.py', [leaf2, leaf3]);
+            const fileItem = createMockTestItem('test_file.py', '/test.py', [class1, class2]);
+
+            // Run
+            const result = getTestCaseNodesRecursive(fileItem);
+
+            // Assert - use Set for order-agnostic comparison
+            expect(result).to.have.length(3);
+            expect(new Set(result)).to.deep.equal(new Set([leaf1, leaf2, leaf3]));
+        });
+    });
+
+    // ===== executeTestsForProject Tests =====
+
+    suite('executeTestsForProject', () => {
+        test('should call executionAdapter.runTests with project URI and mapped test IDs', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            project.resultResolver.vsIdToRunId.set('test1', 'test_file.py::test1');
+            const testItem = createMockTestItem('test1', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProject(project, [testItem], runMock.object, request, deps);
+
+            // Assert
+            expect(project.executionAdapterStub.calledOnce).to.be.true;
+            const callArgs = project.executionAdapterStub.firstCall.args;
+            expect(callArgs[0].fsPath).to.equal(project.projectUri.fsPath); // uri
+            expect(callArgs[1]).to.deep.equal(['test_file.py::test1']); // testCaseIds
+            expect(callArgs[7]).to.equal(project); // project
+        });
+
+        test('should mark all leaf test items as started in the test run', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            project.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            project.resultResolver.vsIdToRunId.set('test2', 'runId2');
+            const item1 = createMockTestItem('test1', '/workspace/proj/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProject(project, [item1, item2], runMock.object, request, deps);
+
+            // Assert - both items marked as started
+            runMock.verify((r) => r.started(item1), typemoq.Times.once());
+            runMock.verify((r) => r.started(item2), typemoq.Times.once());
+        });
+
+        test('should resolve test IDs via resultResolver.vsIdToRunId mapping', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            project.resultResolver.vsIdToRunId.set('test1', 'path/to/test1');
+            project.resultResolver.vsIdToRunId.set('test2', 'path/to/test2');
+            const item1 = createMockTestItem('test1', '/workspace/proj/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProject(project, [item1, item2], runMock.object, request, deps);
+
+            // Assert - use Set for order-agnostic comparison
+            const passedTestIds = project.executionAdapterStub.firstCall.args[1] as string[];
+            expect(new Set(passedTestIds)).to.deep.equal(new Set(['path/to/test1', 'path/to/test2']));
+        });
+
+        test('should skip execution when no items have vsIdToRunId mappings', async () => {
+            // Mock - no mappings set, so lookups return undefined
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const item = createMockTestItem('unmapped_test', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProject(project, [item], runMock.object, request, deps);
+
+            // Assert - execution adapter never called
+            expect(project.executionAdapterStub.called).to.be.false;
+        });
+
+        test('should recursively expand nested test items to find leaf nodes', async () => {
+            // Mock - class containing two test methods
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const leaf1 = createMockTestItem('test1', '/workspace/proj/test.py');
+            const leaf2 = createMockTestItem('test2', '/workspace/proj/test.py');
+            const classItem = createMockTestItem('TestClass', '/workspace/proj/test.py', [leaf1, leaf2]);
+            project.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            project.resultResolver.vsIdToRunId.set('test2', 'runId2');
+            const runMock = createMockTestRun();
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProject(project, [classItem], runMock.object, request, deps);
+
+            // Assert - leaf nodes marked as started, not the parent class
+            runMock.verify((r) => r.started(leaf1), typemoq.Times.once());
+            runMock.verify((r) => r.started(leaf2), typemoq.Times.once());
+            const passedTestIds = project.executionAdapterStub.firstCall.args[1] as string[];
+            expect(passedTestIds).to.have.length(2);
+        });
+    });
+
+    // ===== executeTestsForProjects Tests =====
+
+    suite('executeTestsForProjects', () => {
+        let telemetryStub: sinon.SinonStub;
+
+        setup(() => {
+            telemetryStub = sandbox.stub(telemetry, 'sendTelemetryEvent');
+        });
+
+        test('should return immediately when empty projects array provided', async () => {
+            // Mock
+            const runMock = createMockTestRun();
+            const token = new CancellationTokenSource().token;
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects([], [], runMock.object, request, token, deps);
+
+            // Assert - no telemetry sent since no projects executed
+            expect(telemetryStub.called).to.be.false;
+        });
+
+        test('should skip execution when cancellation requested before start', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const item = createMockTestItem('test1', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const tokenSource = new CancellationTokenSource();
+            tokenSource.cancel(); // Pre-cancel
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects([project], [item], runMock.object, request, tokenSource.token, deps);
+
+            // Assert - execution adapter never called
+            expect(project.executionAdapterStub.called).to.be.false;
+        });
+
+        test('should execute tests for each project when multiple projects provided', async () => {
+            // Mock
+            const proj1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const proj2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+            proj1.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            proj2.resultResolver.vsIdToRunId.set('test2', 'runId2');
+            const item1 = createMockTestItem('test1', '/workspace/proj1/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj2/test.py');
+            const runMock = createMockTestRun();
+            const token = new CancellationTokenSource().token;
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects([proj1, proj2], [item1, item2], runMock.object, request, token, deps);
+
+            // Assert - both projects had their execution adapters called
+            expect(proj1.executionAdapterStub.calledOnce).to.be.true;
+            expect(proj2.executionAdapterStub.calledOnce).to.be.true;
+        });
+
+        test('should emit telemetry event for each project execution', async () => {
+            // Mock
+            const proj1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const proj2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+            proj1.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            proj2.resultResolver.vsIdToRunId.set('test2', 'runId2');
+            const item1 = createMockTestItem('test1', '/workspace/proj1/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj2/test.py');
+            const runMock = createMockTestRun();
+            const token = new CancellationTokenSource().token;
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects([proj1, proj2], [item1, item2], runMock.object, request, token, deps);
+
+            // Assert - telemetry sent twice (once per project)
+            expect(telemetryStub.callCount).to.equal(2);
+        });
+
+        test('should stop processing remaining projects when cancellation requested mid-execution', async () => {
+            // Mock
+            const tokenSource = new CancellationTokenSource();
+            const proj1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const proj2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+            // First project triggers cancellation during its execution
+            proj1.executionAdapterStub.callsFake(async () => {
+                tokenSource.cancel();
+            });
+            proj1.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            proj2.resultResolver.vsIdToRunId.set('test2', 'runId2');
+            const item1 = createMockTestItem('test1', '/workspace/proj1/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj2/test.py');
+            const runMock = createMockTestRun();
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects(
+                [proj1, proj2],
+                [item1, item2],
+                runMock.object,
+                request,
+                tokenSource.token,
+                deps,
+            );
+
+            // Assert - first project executed, second may be skipped due to cancellation check
+            expect(proj1.executionAdapterStub.calledOnce).to.be.true;
+        });
+
+        test('should continue executing remaining projects when one project fails', async () => {
+            // Mock
+            const proj1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const proj2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+            proj1.executionAdapterStub.rejects(new Error('Execution failed'));
+            proj1.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            proj2.resultResolver.vsIdToRunId.set('test2', 'runId2');
+            const item1 = createMockTestItem('test1', '/workspace/proj1/test.py');
+            const item2 = createMockTestItem('test2', '/workspace/proj2/test.py');
+            const runMock = createMockTestRun();
+            const token = new CancellationTokenSource().token;
+            const request = { profile: { kind: TestRunProfileKind.Run } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run - should not throw
+            await executeTestsForProjects([proj1, proj2], [item1, item2], runMock.object, request, token, deps);
+
+            // Assert - second project still executed despite first failing
+            expect(proj2.executionAdapterStub.calledOnce).to.be.true;
+        });
+
+        test('should configure loadDetailedCoverage callback when run profile is Coverage', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            project.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            const item = createMockTestItem('test1', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const token = new CancellationTokenSource().token;
+            const profileMock = ({
+                kind: TestRunProfileKind.Coverage,
+                loadDetailedCoverage: undefined,
+            } as unknown) as TestRunProfile;
+            const request = { profile: profileMock } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects([project], [item], runMock.object, request, token, deps);
+
+            // Assert - loadDetailedCoverage callback was configured
+            expect(profileMock.loadDetailedCoverage).to.not.be.undefined;
+        });
+
+        test('should include debugging=true in telemetry when run profile is Debug', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            project.resultResolver.vsIdToRunId.set('test1', 'runId1');
+            const item = createMockTestItem('test1', '/workspace/proj/test.py');
+            const runMock = createMockTestRun();
+            const token = new CancellationTokenSource().token;
+            const request = { profile: { kind: TestRunProfileKind.Debug } } as TestRunRequest;
+            const deps = createMockDependencies();
+
+            // Run
+            await executeTestsForProjects([project], [item], runMock.object, request, token, deps);
+
+            // Assert - telemetry contains debugging=true
+            expect(telemetryStub.calledOnce).to.be.true;
+            const telemetryProps = telemetryStub.firstCall.args[2];
+            expect(telemetryProps.debugging).to.be.true;
+        });
+    });
+
+    // ===== setupCoverageForProjects Tests =====
+
+    suite('setupCoverageForProjects', () => {
+        test('should configure loadDetailedCoverage callback when profile kind is Coverage', () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const profileMock = ({
+                kind: TestRunProfileKind.Coverage,
+                loadDetailedCoverage: undefined,
+            } as unknown) as TestRunProfile;
+            const request = { profile: profileMock } as TestRunRequest;
+
+            // Run
+            setupCoverageForProjects(request, [project]);
+
+            // Assert
+            expect(profileMock.loadDetailedCoverage).to.be.a('function');
+        });
+
+        test('should leave loadDetailedCoverage undefined when profile kind is Run', () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const profileMock = ({
+                kind: TestRunProfileKind.Run,
+                loadDetailedCoverage: undefined,
+            } as unknown) as TestRunProfile;
+            const request = { profile: profileMock } as TestRunRequest;
+
+            // Run
+            setupCoverageForProjects(request, [project]);
+
+            // Assert
+            expect(profileMock.loadDetailedCoverage).to.be.undefined;
+        });
+
+        test('should return coverage data from detailedCoverageMap when loadDetailedCoverage is called', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const mockCoverageDetails = [{ line: 1, executed: true }];
+            // Use Uri.fsPath as the key to match the implementation's lookup
+            const fileUri = Uri.file('/workspace/proj/file.py');
+            project.resultResolver.detailedCoverageMap.set(fileUri.fsPath, mockCoverageDetails as any);
+            const profileMock = ({
+                kind: TestRunProfileKind.Coverage,
+                loadDetailedCoverage: undefined,
+            } as unknown) as TestRunProfile;
+            const request = { profile: profileMock } as TestRunRequest;
+
+            // Run - configure coverage
+            setupCoverageForProjects(request, [project]);
+
+            // Run - call the configured callback
+            const fileCoverage = { uri: fileUri };
+            const result = await profileMock.loadDetailedCoverage!(
+                {} as TestRun,
+                fileCoverage as any,
+                {} as CancellationToken,
+            );
+
+            // Assert
+            expect(result).to.deep.equal(mockCoverageDetails);
+        });
+
+        test('should return empty array when file has no coverage data in map', async () => {
+            // Mock
+            const project = createMockProjectAdapter({ projectPath: '/workspace/proj', projectName: 'proj' });
+            const profileMock = ({
+                kind: TestRunProfileKind.Coverage,
+                loadDetailedCoverage: undefined,
+            } as unknown) as TestRunProfile;
+            const request = { profile: profileMock } as TestRunRequest;
+
+            // Run - configure coverage
+            setupCoverageForProjects(request, [project]);
+
+            // Run - call callback for file not in map
+            const fileCoverage = { uri: Uri.file('/workspace/proj/uncovered_file.py') };
+            const result = await profileMock.loadDetailedCoverage!(
+                {} as TestRun,
+                fileCoverage as any,
+                {} as CancellationToken,
+            );
+
+            // Assert
+            expect(result).to.deep.equal([]);
+        });
+
+        test('should route to correct project when multiple projects have coverage data', async () => {
+            // Mock - two projects with different coverage data
+            const project1 = createMockProjectAdapter({ projectPath: '/workspace/proj1', projectName: 'proj1' });
+            const project2 = createMockProjectAdapter({ projectPath: '/workspace/proj2', projectName: 'proj2' });
+            const coverage1 = [{ line: 1, executed: true }];
+            const coverage2 = [{ line: 2, executed: false }];
+            const file1Uri = Uri.file('/workspace/proj1/file1.py');
+            const file2Uri = Uri.file('/workspace/proj2/file2.py');
+            project1.resultResolver.detailedCoverageMap.set(file1Uri.fsPath, coverage1 as any);
+            project2.resultResolver.detailedCoverageMap.set(file2Uri.fsPath, coverage2 as any);
+
+            const profileMock = ({
+                kind: TestRunProfileKind.Coverage,
+                loadDetailedCoverage: undefined,
+            } as unknown) as TestRunProfile;
+            const request = { profile: profileMock } as TestRunRequest;
+
+            // Run - configure coverage with both projects
+            setupCoverageForProjects(request, [project1, project2]);
+
+            // Assert - can get coverage from both projects through single callback
+            const result1 = await profileMock.loadDetailedCoverage!(
+                {} as TestRun,
+                { uri: file1Uri } as any,
+                {} as CancellationToken,
+            );
+            const result2 = await profileMock.loadDetailedCoverage!(
+                {} as TestRun,
+                { uri: file2Uri } as any,
+                {} as CancellationToken,
+            );
+
+            expect(result1).to.deep.equal(coverage1);
+            expect(result2).to.deep.equal(coverage2);
+        });
+    });
+});
diff --git a/src/test/testing/testController/common/projectUtils.unit.test.ts b/src/test/testing/testController/common/projectUtils.unit.test.ts
new file mode 100644
index 000000000000..75f399e89fc0
--- /dev/null
+++ b/src/test/testing/testController/common/projectUtils.unit.test.ts
@@ -0,0 +1,241 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import { Uri } from 'vscode';
+import {
+    getProjectId,
+    createProjectDisplayName,
+    parseVsId,
+    PROJECT_ID_SEPARATOR,
+} from '../../../../client/testing/testController/common/projectUtils';
+
+suite('Project Utils Tests', () => {
+    suite('getProjectId', () => {
+        test('should return URI string representation', () => {
+            const uri = Uri.file('/workspace/project');
+
+            const id = getProjectId(uri);
+
+            expect(id).to.equal(uri.toString());
+        });
+
+        test('should be consistent for same URI', () => {
+            const uri = Uri.file('/workspace/project');
+
+            const id1 = getProjectId(uri);
+            const id2 = getProjectId(uri);
+
+            expect(id1).to.equal(id2);
+        });
+
+        test('should be different for different URIs', () => {
+            const uri1 = Uri.file('/workspace/project1');
+            const uri2 = Uri.file('/workspace/project2');
+
+            const id1 = getProjectId(uri1);
+            const id2 = getProjectId(uri2);
+
+            expect(id1).to.not.equal(id2);
+        });
+
+        test('should handle Windows paths', () => {
+            const uri = Uri.file('C:\\workspace\\project');
+
+            const id = getProjectId(uri);
+
+            expect(id).to.be.a('string');
+            expect(id).to.have.length.greaterThan(0);
+        });
+
+        test('should handle nested project paths', () => {
+            const parentUri = Uri.file('/workspace/parent');
+            const childUri = Uri.file('/workspace/parent/child');
+
+            const parentId = getProjectId(parentUri);
+            const childId = getProjectId(childUri);
+
+            expect(parentId).to.not.equal(childId);
+        });
+
+        test('should match Python Environments extension format', () => {
+            const uri = Uri.file('/workspace/project');
+
+            const id = getProjectId(uri);
+
+            // Should match how Python Environments extension keys projects
+            expect(id).to.equal(uri.toString());
+            expect(typeof id).to.equal('string');
+        });
+    });
+
+    suite('createProjectDisplayName', () => {
+        test('should format name with major.minor version', () => {
+            const result = createProjectDisplayName('MyProject', '3.11.2');
+
+            expect(result).to.equal('MyProject (Python 3.11)');
+        });
+
+        test('should handle version with patch and pre-release', () => {
+            const result = createProjectDisplayName('MyProject', '3.12.0rc1');
+
+            expect(result).to.equal('MyProject (Python 3.12)');
+        });
+
+        test('should handle version with only major.minor', () => {
+            const result = createProjectDisplayName('MyProject', '3.10');
+
+            expect(result).to.equal('MyProject (Python 3.10)');
+        });
+
+        test('should handle invalid version format gracefully', () => {
+            const result = createProjectDisplayName('MyProject', 'invalid-version');
+
+            expect(result).to.equal('MyProject (Python invalid-version)');
+        });
+
+        test('should handle empty version string', () => {
+            const result = createProjectDisplayName('MyProject', '');
+
+            expect(result).to.equal('MyProject (Python )');
+        });
+
+        test('should handle version with single digit', () => {
+            const result = createProjectDisplayName('MyProject', '3');
+
+            expect(result).to.equal('MyProject (Python 3)');
+        });
+
+        test('should handle project name with special characters', () => {
+            const result = createProjectDisplayName('My-Project_123', '3.11.5');
+
+            expect(result).to.equal('My-Project_123 (Python 3.11)');
+        });
+
+        test('should handle empty project name', () => {
+            const result = createProjectDisplayName('', '3.11.2');
+
+            expect(result).to.equal(' (Python 3.11)');
+        });
+    });
+
+    suite('parseVsId', () => {
+        test('should parse project-scoped ID correctly', () => {
+            const projectUri = Uri.file('/workspace/project');
+            const projectId = getProjectId(projectUri);
+            const vsId = `${projectId}${PROJECT_ID_SEPARATOR}test_file.py::test_name`;
+
+            const [parsedProjectId, runId] = parseVsId(vsId);
+
+            expect(parsedProjectId).to.equal(projectId);
+            expect(runId).to.equal('test_file.py::test_name');
+        });
+
+        test('should handle legacy ID without project scope', () => {
+            const vsId = 'test_file.py';
+
+            const [projectId, runId] = parseVsId(vsId);
+
+            expect(projectId).to.be.undefined;
+            expect(runId).to.equal('test_file.py');
+        });
+
+        test('should handle runId containing separator', () => {
+            const projectUri = Uri.file('/workspace/project');
+            const projectId = getProjectId(projectUri);
+            const vsId = `${projectId}${PROJECT_ID_SEPARATOR}test_file.py::test_class::test_method`;
+
+            const [parsedProjectId, runId] = parseVsId(vsId);
+
+            expect(parsedProjectId).to.equal(projectId);
+            expect(runId).to.equal('test_file.py::test_class::test_method');
+        });
+
+        test('should handle empty project ID', () => {
+            const vsId = `${PROJECT_ID_SEPARATOR}test_file.py::test_name`;
+
+            const [projectId, runId] = parseVsId(vsId);
+
+            expect(projectId).to.equal('');
+            expect(runId).to.equal('test_file.py::test_name');
+        });
+
+        test('should handle empty runId', () => {
+            const vsId = `project-abc123def456${PROJECT_ID_SEPARATOR}`;
+
+            const [projectId, runId] = parseVsId(vsId);
+
+            expect(projectId).to.equal('project-abc123def456');
+            expect(runId).to.equal('');
+        });
+
+        test('should handle ID with file path', () => {
+            const vsId = `project-abc123def456${PROJECT_ID_SEPARATOR}/workspace/tests/test_file.py`;
+
+            const [projectId, runId] = parseVsId(vsId);
+
+            expect(projectId).to.equal('project-abc123def456');
+            expect(runId).to.equal('/workspace/tests/test_file.py');
+        });
+
+        test('should handle Windows file paths', () => {
+            const projectUri = Uri.file('/workspace/project');
+            const projectId = getProjectId(projectUri);
+            const vsId = `${projectId}${PROJECT_ID_SEPARATOR}C:\\workspace\\tests\\test_file.py`;
+
+            const [parsedProjectId, runId] = parseVsId(vsId);
+
+            expect(parsedProjectId).to.equal(projectId);
+            expect(runId).to.equal('C:\\workspace\\tests\\test_file.py');
+        });
+    });
+
+    suite('Integration Tests', () => {
+        test('should generate unique IDs for different URIs', () => {
+            const uris = [
+                Uri.file('/workspace/a'),
+                Uri.file('/workspace/b'),
+                Uri.file('/workspace/c'),
+                Uri.file('/workspace/d'),
+                Uri.file('/workspace/e'),
+            ];
+
+            const ids = uris.map((uri) => getProjectId(uri));
+            const uniqueIds = new Set(ids);
+
+            expect(uniqueIds.size).to.equal(uris.length, 'All IDs should be unique');
+        });
+
+        test('should handle nested project paths', () => {
+            const parentUri = Uri.file('/workspace/parent');
+            const childUri = Uri.file('/workspace/parent/child');
+
+            const parentId = getProjectId(parentUri);
+            const childId = getProjectId(childUri);
+
+            expect(parentId).to.not.equal(childId);
+        });
+
+        test('should create complete vsId and parse it back', () => {
+            const projectUri = Uri.file('/workspace/myproject');
+            const projectId = getProjectId(projectUri);
+            const runId = 'tests/test_module.py::TestClass::test_method';
+            const vsId = `${projectId}${PROJECT_ID_SEPARATOR}${runId}`;
+
+            const [parsedProjectId, parsedRunId] = parseVsId(vsId);
+
+            expect(parsedProjectId).to.equal(projectId);
+            expect(parsedRunId).to.equal(runId);
+        });
+
+        test('should match Python Environments extension URI format', () => {
+            const uri = Uri.file('/workspace/project');
+
+            const projectId = getProjectId(uri);
+
+            // Should be string representation of URI
+            expect(projectId).to.equal(uri.toString());
+            expect(typeof projectId).to.equal('string');
+        });
+    });
+});
diff --git a/src/test/testing/testController/common/testCoverageHandler.unit.test.ts b/src/test/testing/testController/common/testCoverageHandler.unit.test.ts
new file mode 100644
index 000000000000..a81aed591128
--- /dev/null
+++ b/src/test/testing/testController/common/testCoverageHandler.unit.test.ts
@@ -0,0 +1,502 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestRun, Uri, FileCoverage } from 'vscode';
+import * as typemoq from 'typemoq';
+import * as assert from 'assert';
+import { TestCoverageHandler } from '../../../../client/testing/testController/common/testCoverageHandler';
+import { CoveragePayload } from '../../../../client/testing/testController/common/types';
+
+suite('TestCoverageHandler', () => {
+    let coverageHandler: TestCoverageHandler;
+    let runInstanceMock: typemoq.IMock<TestRun>;
+
+    setup(() => {
+        coverageHandler = new TestCoverageHandler();
+        runInstanceMock = typemoq.Mock.ofType<TestRun>();
+    });
+
+    suite('processCoverage', () => {
+        test('should return empty map for undefined result', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: undefined,
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.strictEqual(result.size, 0);
+            runInstanceMock.verify((r) => r.addCoverage(typemoq.It.isAny()), typemoq.Times.never());
+        });
+
+        test('should create FileCoverage for each file', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file1.py': {
+                        lines_covered: [1, 2, 3],
+                        lines_missed: [4, 5],
+                        executed_branches: 5,
+                        total_branches: 10,
+                    },
+                    '/path/to/file2.py': {
+                        lines_covered: [1, 2],
+                        lines_missed: [3],
+                        executed_branches: 2,
+                        total_branches: 4,
+                    },
+                },
+                error: '',
+            };
+
+            coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            runInstanceMock.verify((r) => r.addCoverage(typemoq.It.isAny()), typemoq.Times.exactly(2));
+        });
+
+        test('should call runInstance.addCoverage with correct FileCoverage', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2, 3],
+                        lines_missed: [4, 5],
+                        executed_branches: 5,
+                        total_branches: 10,
+                    },
+                },
+                error: '',
+            };
+
+            let capturedCoverage: FileCoverage | undefined;
+            runInstanceMock
+                .setup((r) => r.addCoverage(typemoq.It.isAny()))
+                .callback((coverage: FileCoverage) => {
+                    capturedCoverage = coverage;
+                });
+
+            coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.ok(capturedCoverage);
+            assert.strictEqual(capturedCoverage!.uri.fsPath, Uri.file('/path/to/file.py').fsPath);
+        });
+
+        test('should return detailed coverage map with correct keys', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file1.py': {
+                        lines_covered: [1, 2],
+                        lines_missed: [3],
+                        executed_branches: 2,
+                        total_branches: 4,
+                    },
+                    '/path/to/file2.py': {
+                        lines_covered: [5, 6, 7],
+                        lines_missed: [],
+                        executed_branches: 3,
+                        total_branches: 3,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.strictEqual(result.size, 2);
+            assert.ok(result.has(Uri.file('/path/to/file1.py').fsPath));
+            assert.ok(result.has(Uri.file('/path/to/file2.py').fsPath));
+        });
+
+        test('should handle empty coverage data', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {},
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.strictEqual(result.size, 0);
+        });
+
+        test('should handle file with no covered lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [],
+                        lines_missed: [1, 2, 3],
+                        executed_branches: 0,
+                        total_branches: 5,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 3); // Only missed lines
+        });
+
+        test('should handle file with no missed lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2, 3],
+                        lines_missed: [],
+                        executed_branches: 5,
+                        total_branches: 5,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 3); // Only covered lines
+        });
+
+        test('should handle undefined lines_covered', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: undefined as any,
+                        lines_missed: [1, 2],
+                        executed_branches: 0,
+                        total_branches: 2,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 2); // Only missed lines
+        });
+
+        test('should handle undefined lines_missed', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2],
+                        lines_missed: undefined as any,
+                        executed_branches: 2,
+                        total_branches: 2,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 2); // Only covered lines
+        });
+    });
+
+    suite('createFileCoverage', () => {
+        test('should handle line coverage only when totalBranches is -1', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2, 3],
+                        lines_missed: [4, 5],
+                        executed_branches: 0,
+                        total_branches: -1, // Branch coverage disabled
+                    },
+                },
+                error: '',
+            };
+
+            let capturedCoverage: FileCoverage | undefined;
+            runInstanceMock
+                .setup((r) => r.addCoverage(typemoq.It.isAny()))
+                .callback((coverage: FileCoverage) => {
+                    capturedCoverage = coverage;
+                });
+
+            coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.ok(capturedCoverage);
+            // Branch coverage should not be included
+            assert.strictEqual((capturedCoverage as any).branchCoverage, undefined);
+        });
+
+        test('should include branch coverage when available', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2, 3],
+                        lines_missed: [4],
+                        executed_branches: 7,
+                        total_branches: 10,
+                    },
+                },
+                error: '',
+            };
+
+            let capturedCoverage: FileCoverage | undefined;
+            runInstanceMock
+                .setup((r) => r.addCoverage(typemoq.It.isAny()))
+                .callback((coverage: FileCoverage) => {
+                    capturedCoverage = coverage;
+                });
+
+            coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.ok(capturedCoverage);
+            // Should have branch coverage
+            assert.ok((capturedCoverage as any).branchCoverage);
+        });
+
+        test('should calculate line coverage counts correctly', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2, 3, 4, 5],
+                        lines_missed: [6, 7],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            let capturedCoverage: FileCoverage | undefined;
+            runInstanceMock
+                .setup((r) => r.addCoverage(typemoq.It.isAny()))
+                .callback((coverage: FileCoverage) => {
+                    capturedCoverage = coverage;
+                });
+
+            coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            assert.ok(capturedCoverage);
+            // 5 covered out of 7 total (5 covered + 2 missed)
+            assert.strictEqual((capturedCoverage as any).statementCoverage.covered, 5);
+            assert.strictEqual((capturedCoverage as any).statementCoverage.total, 7);
+        });
+    });
+
+    suite('createDetailedCoverage', () => {
+        test('should create StatementCoverage for covered lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 2, 3],
+                        lines_missed: [],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 3);
+
+            // All should be covered (true)
+            detailedCoverage!.forEach((coverage) => {
+                assert.strictEqual((coverage as any).executed, true);
+            });
+        });
+
+        test('should create StatementCoverage for missed lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [],
+                        lines_missed: [1, 2, 3],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 3);
+
+            // All should be NOT covered (false)
+            detailedCoverage!.forEach((coverage) => {
+                assert.strictEqual((coverage as any).executed, false);
+            });
+        });
+
+        test('should convert 1-indexed to 0-indexed line numbers for covered lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 5, 10],
+                        lines_missed: [],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+
+            // Line 1 should map to range starting at line 0
+            assert.strictEqual((detailedCoverage![0] as any).location.start.line, 0);
+            // Line 5 should map to range starting at line 4
+            assert.strictEqual((detailedCoverage![1] as any).location.start.line, 4);
+            // Line 10 should map to range starting at line 9
+            assert.strictEqual((detailedCoverage![2] as any).location.start.line, 9);
+        });
+
+        test('should convert 1-indexed to 0-indexed line numbers for missed lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [],
+                        lines_missed: [3, 7, 12],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+
+            // Line 3 should map to range starting at line 2
+            assert.strictEqual((detailedCoverage![0] as any).location.start.line, 2);
+            // Line 7 should map to range starting at line 6
+            assert.strictEqual((detailedCoverage![1] as any).location.start.line, 6);
+            // Line 12 should map to range starting at line 11
+            assert.strictEqual((detailedCoverage![2] as any).location.start.line, 11);
+        });
+
+        test('should handle large line numbers', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1000, 5000, 10000],
+                        lines_missed: [],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 3);
+
+            // Verify conversion is correct for large numbers
+            assert.strictEqual((detailedCoverage![0] as any).location.start.line, 999);
+            assert.strictEqual((detailedCoverage![1] as any).location.start.line, 4999);
+            assert.strictEqual((detailedCoverage![2] as any).location.start.line, 9999);
+        });
+
+        test('should create detailed coverage with both covered and missed lines', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1, 3, 5],
+                        lines_missed: [2, 4, 6],
+                        executed_branches: 3,
+                        total_branches: 6,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+            assert.strictEqual(detailedCoverage!.length, 6); // 3 covered + 3 missed
+
+            // Count covered vs not covered
+            const covered = detailedCoverage!.filter((c) => (c as any).executed === true);
+            const notCovered = detailedCoverage!.filter((c) => (c as any).executed === false);
+
+            assert.strictEqual(covered.length, 3);
+            assert.strictEqual(notCovered.length, 3);
+        });
+
+        test('should set range to cover entire line', () => {
+            const payload: CoveragePayload = {
+                coverage: true,
+                cwd: '/foo/bar',
+                result: {
+                    '/path/to/file.py': {
+                        lines_covered: [1],
+                        lines_missed: [],
+                        executed_branches: 0,
+                        total_branches: -1,
+                    },
+                },
+                error: '',
+            };
+
+            const result = coverageHandler.processCoverage(payload, runInstanceMock.object);
+
+            const detailedCoverage = result.get(Uri.file('/path/to/file.py').fsPath);
+            assert.ok(detailedCoverage);
+
+            const coverage = detailedCoverage![0] as any;
+            // Start at column 0
+            assert.strictEqual(coverage.location.start.character, 0);
+            // End at max safe integer (entire line)
+            assert.strictEqual(coverage.location.end.character, Number.MAX_SAFE_INTEGER);
+        });
+    });
+});
diff --git a/src/test/testing/testController/common/testDiscoveryHandler.unit.test.ts b/src/test/testing/testController/common/testDiscoveryHandler.unit.test.ts
new file mode 100644
index 000000000000..458e3d984405
--- /dev/null
+++ b/src/test/testing/testController/common/testDiscoveryHandler.unit.test.ts
@@ -0,0 +1,517 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestController, TestItem, Uri, CancellationToken, TestItemCollection } from 'vscode';
+import * as typemoq from 'typemoq';
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { TestDiscoveryHandler } from '../../../../client/testing/testController/common/testDiscoveryHandler';
+import { TestItemIndex } from '../../../../client/testing/testController/common/testItemIndex';
+import { DiscoveredTestPayload, DiscoveredTestNode } from '../../../../client/testing/testController/common/types';
+import { TestProvider } from '../../../../client/testing/types';
+import * as utils from '../../../../client/testing/testController/common/utils';
+import * as testItemUtilities from '../../../../client/testing/testController/common/testItemUtilities';
+
+suite('TestDiscoveryHandler', () => {
+    let discoveryHandler: TestDiscoveryHandler;
+    let testControllerMock: typemoq.IMock<TestController>;
+    let testItemIndexMock: typemoq.IMock<TestItemIndex>;
+    let testItemCollectionMock: typemoq.IMock<TestItemCollection>;
+    let workspaceUri: Uri;
+    let testProvider: TestProvider;
+    let cancelationToken: CancellationToken;
+
+    setup(() => {
+        discoveryHandler = new TestDiscoveryHandler();
+        testControllerMock = typemoq.Mock.ofType<TestController>();
+        testItemIndexMock = typemoq.Mock.ofType<TestItemIndex>();
+        testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+
+        // Setup default test controller items mock
+        testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+        testItemCollectionMock.setup((x) => x.delete(typemoq.It.isAny())).returns(() => undefined);
+        testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+        testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+
+        workspaceUri = Uri.file('/foo/bar');
+        testProvider = 'pytest';
+        cancelationToken = ({
+            isCancellationRequested: false,
+        } as unknown) as CancellationToken;
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    suite('processDiscovery', () => {
+        test('should handle null payload gracefully', () => {
+            discoveryHandler.processDiscovery(
+                null as any,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            // Should not throw and should not call populateTestTree
+            testItemIndexMock.verify((x) => x.clear(), typemoq.Times.never());
+        });
+
+        test('should call populateTestTree with correct params on success', () => {
+            const tests: DiscoveredTestNode = {
+                path: '/foo/bar',
+                name: 'root',
+                type_: 'folder',
+                id_: 'root_id',
+                children: [],
+            };
+
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'success',
+                tests,
+            };
+
+            const populateTestTreeStub = sinon.stub(utils, 'populateTestTree');
+            testItemIndexMock.setup((x) => x.clear()).returns(() => undefined);
+
+            // Setup map getters for populateTestTree
+            const mockRunIdMap = new Map();
+            const mockVSidMap = new Map();
+            const mockVStoRunMap = new Map();
+            testItemIndexMock.setup((x) => x.runIdToTestItemMap).returns(() => mockRunIdMap);
+            testItemIndexMock.setup((x) => x.runIdToVSidMap).returns(() => mockVSidMap);
+            testItemIndexMock.setup((x) => x.vsIdToRunIdMap).returns(() => mockVStoRunMap);
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            testItemIndexMock.verify((x) => x.clear(), typemoq.Times.once());
+            assert.ok(populateTestTreeStub.calledOnce);
+            sinon.assert.calledWith(
+                populateTestTreeStub,
+                testControllerMock.object,
+                tests,
+                undefined,
+                sinon.match.any,
+                cancelationToken,
+            );
+        });
+
+        test('should clear index before populating', () => {
+            const tests: DiscoveredTestNode = {
+                path: '/foo/bar',
+                name: 'root',
+                type_: 'folder',
+                id_: 'root_id',
+                children: [],
+            };
+
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'success',
+                tests,
+            };
+
+            sinon.stub(utils, 'populateTestTree');
+
+            const clearSpy = sinon.spy();
+            testItemIndexMock.setup((x) => x.clear()).callback(clearSpy);
+            testItemIndexMock.setup((x) => x.runIdToTestItemMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.runIdToVSidMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.vsIdToRunIdMap).returns(() => new Map());
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            assert.ok(clearSpy.calledOnce);
+        });
+
+        test('should handle error status and create error node', () => {
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'error',
+                error: ['Error message 1', 'Error message 2'],
+            };
+
+            const createErrorNodeSpy = sinon.spy(discoveryHandler, 'createErrorNode');
+
+            // Mock createTestItem to return a proper TestItem
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+                canResolveChildren: false,
+                tags: [],
+            } as unknown) as TestItem;
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => mockErrorItem);
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            assert.ok(createErrorNodeSpy.calledOnce);
+            assert.ok(
+                createErrorNodeSpy.calledWith(testControllerMock.object, workspaceUri, payload.error, testProvider),
+            );
+        });
+
+        test('should handle both errors and tests in same payload', () => {
+            const tests: DiscoveredTestNode = {
+                path: '/foo/bar',
+                name: 'root',
+                type_: 'folder',
+                id_: 'root_id',
+                children: [],
+            };
+
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'error',
+                error: ['Partial error'],
+                tests,
+            };
+
+            sinon.stub(utils, 'populateTestTree');
+            const createErrorNodeSpy = sinon.spy(discoveryHandler, 'createErrorNode');
+
+            // Mock createTestItem to return a proper TestItem
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+                canResolveChildren: false,
+                tags: [],
+            } as unknown) as TestItem;
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => mockErrorItem);
+
+            testItemIndexMock.setup((x) => x.clear()).returns(() => undefined);
+            testItemIndexMock.setup((x) => x.runIdToTestItemMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.runIdToVSidMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.vsIdToRunIdMap).returns(() => new Map());
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            // Should create error node AND populate test tree
+            assert.ok(createErrorNodeSpy.calledOnce);
+            testItemIndexMock.verify((x) => x.clear(), typemoq.Times.once());
+        });
+
+        test('should delete error node on successful discovery', () => {
+            const tests: DiscoveredTestNode = {
+                path: '/foo/bar',
+                name: 'root',
+                type_: 'folder',
+                id_: 'root_id',
+                children: [],
+            };
+
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'success',
+                tests,
+            };
+
+            const deleteSpy = sinon.spy();
+            // Reset and reconfigure the collection mock to capture delete call
+            testItemCollectionMock.reset();
+            testItemCollectionMock
+                .setup((x) => x.delete(typemoq.It.isAny()))
+                .callback(deleteSpy)
+                .returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.reset();
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            sinon.stub(utils, 'populateTestTree');
+            testItemIndexMock.setup((x) => x.clear()).returns(() => undefined);
+            testItemIndexMock.setup((x) => x.runIdToTestItemMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.runIdToVSidMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.vsIdToRunIdMap).returns(() => new Map());
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            assert.ok(deleteSpy.calledOnce);
+            assert.ok(deleteSpy.calledWith(`DiscoveryError:${workspaceUri.fsPath}`));
+        });
+
+        test('should respect cancellation token', () => {
+            const tests: DiscoveredTestNode = {
+                path: '/foo/bar',
+                name: 'root',
+                type_: 'folder',
+                id_: 'root_id',
+                children: [],
+            };
+
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'success',
+                tests,
+            };
+
+            const populateTestTreeStub = sinon.stub(utils, 'populateTestTree');
+            testItemIndexMock.setup((x) => x.clear()).returns(() => undefined);
+            testItemIndexMock.setup((x) => x.runIdToTestItemMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.runIdToVSidMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.vsIdToRunIdMap).returns(() => new Map());
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            // Verify token was passed to populateTestTree
+            assert.ok(populateTestTreeStub.calledOnce);
+            const lastArg = populateTestTreeStub.getCall(0).args[4];
+            assert.strictEqual(lastArg, cancelationToken);
+        });
+
+        test('should handle null tests in payload', () => {
+            const payload: DiscoveredTestPayload = {
+                cwd: workspaceUri.fsPath,
+                status: 'success',
+                tests: null as any,
+            };
+
+            const populateTestTreeStub = sinon.stub(utils, 'populateTestTree');
+            testItemIndexMock.setup((x) => x.clear()).returns(() => undefined);
+            testItemIndexMock.setup((x) => x.runIdToTestItemMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.runIdToVSidMap).returns(() => new Map());
+            testItemIndexMock.setup((x) => x.vsIdToRunIdMap).returns(() => new Map());
+
+            discoveryHandler.processDiscovery(
+                payload,
+                testControllerMock.object,
+                testItemIndexMock.object,
+                workspaceUri,
+                testProvider,
+                cancelationToken,
+            );
+
+            // Should still call populateTestTree with null
+            assert.ok(populateTestTreeStub.calledOnce);
+            testItemIndexMock.verify((x) => x.clear(), typemoq.Times.once());
+        });
+    });
+
+    suite('createErrorNode', () => {
+        test('should create error with correct message for pytest', () => {
+            const error = ['Error line 1', 'Error line 2'];
+            testProvider = 'pytest';
+
+            const buildErrorNodeOptionsStub = sinon.stub(utils, 'buildErrorNodeOptions').returns({
+                id: 'error_id',
+                label: 'Error Label',
+                error: 'Error Message',
+            });
+
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+            } as unknown) as TestItem;
+
+            const createErrorTestItemStub = sinon.stub(testItemUtilities, 'createErrorTestItem').returns(mockErrorItem);
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            discoveryHandler.createErrorNode(testControllerMock.object, workspaceUri, error, testProvider);
+
+            assert.ok(buildErrorNodeOptionsStub.calledOnce);
+            assert.ok(createErrorTestItemStub.calledOnce);
+            assert.ok(mockErrorItem.error !== null);
+        });
+
+        test('should create error with correct message for unittest', () => {
+            const error = ['Unittest error'];
+            testProvider = 'unittest';
+
+            sinon.stub(utils, 'buildErrorNodeOptions').returns({
+                id: 'error_id',
+                label: 'Error Label',
+                error: 'Error Message',
+            });
+
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+            } as unknown) as TestItem;
+
+            sinon.stub(testItemUtilities, 'createErrorTestItem').returns(mockErrorItem);
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            discoveryHandler.createErrorNode(testControllerMock.object, workspaceUri, error, testProvider);
+
+            assert.ok(mockErrorItem.error !== null);
+        });
+
+        test('should set markdown error label correctly', () => {
+            const error = ['Test error'];
+
+            sinon.stub(utils, 'buildErrorNodeOptions').returns({
+                id: 'error_id',
+                label: 'Error Label',
+                error: 'Error Message',
+            });
+
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+            } as unknown) as TestItem;
+
+            sinon.stub(testItemUtilities, 'createErrorTestItem').returns(mockErrorItem);
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            discoveryHandler.createErrorNode(testControllerMock.object, workspaceUri, error, testProvider);
+
+            assert.ok(mockErrorItem.error);
+            assert.strictEqual(
+                (mockErrorItem.error as any).value,
+                '[Show output](command:python.viewOutput) to view error logs',
+            );
+            assert.strictEqual((mockErrorItem.error as any).isTrusted, true);
+        });
+
+        test('should handle undefined error array', () => {
+            sinon.stub(utils, 'buildErrorNodeOptions').returns({
+                id: 'error_id',
+                label: 'Error Label',
+                error: 'Error Message',
+            });
+
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+            } as unknown) as TestItem;
+
+            sinon.stub(testItemUtilities, 'createErrorTestItem').returns(mockErrorItem);
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            discoveryHandler.createErrorNode(testControllerMock.object, workspaceUri, undefined, testProvider);
+
+            // Should not throw
+            assert.ok(mockErrorItem.error !== null);
+        });
+
+        test('should reuse existing error node if present', () => {
+            const error = ['Error'];
+
+            // Create a proper object with settable error property
+            const existingErrorItem: any = {
+                id: `DiscoveryError:${workspaceUri.fsPath}`,
+                error: null,
+                canResolveChildren: false,
+                tags: [],
+            };
+
+            sinon.stub(utils, 'buildErrorNodeOptions').returns({
+                id: `DiscoveryError:${workspaceUri.fsPath}`,
+                label: 'Error Label',
+                error: 'Error Message',
+            });
+
+            const createErrorTestItemStub = sinon.stub(testItemUtilities, 'createErrorTestItem');
+
+            // Reset and setup collection to return existing item
+            testItemCollectionMock.reset();
+            testItemCollectionMock
+                .setup((x) => x.get(`DiscoveryError:${workspaceUri.fsPath}`))
+                .returns(() => existingErrorItem);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.reset();
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            discoveryHandler.createErrorNode(testControllerMock.object, workspaceUri, error, testProvider);
+
+            // Should not create a new error item
+            assert.ok(createErrorTestItemStub.notCalled);
+            // Should still update the error property
+            assert.ok(existingErrorItem.error !== null);
+        });
+
+        test('should handle multiple error messages', () => {
+            const error = ['Error 1', 'Error 2', 'Error 3'];
+
+            const buildStub = sinon.stub(utils, 'buildErrorNodeOptions').returns({
+                id: 'error_id',
+                label: 'Error Label',
+                error: 'Error Message',
+            });
+
+            const mockErrorItem = ({
+                id: 'error_id',
+                error: null,
+            } as unknown) as TestItem;
+
+            sinon.stub(testItemUtilities, 'createErrorTestItem').returns(mockErrorItem);
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testItemCollectionMock.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            discoveryHandler.createErrorNode(testControllerMock.object, workspaceUri, error, testProvider);
+
+            // Verify the error messages are joined
+            const expectedMessage = sinon.match((value: string) => {
+                return value.includes('Error 1') && value.includes('Error 2') && value.includes('Error 3');
+            });
+            sinon.assert.calledWith(buildStub, workspaceUri, expectedMessage, testProvider);
+        });
+    });
+});
diff --git a/src/test/testing/testController/common/testExecutionHandler.unit.test.ts b/src/test/testing/testController/common/testExecutionHandler.unit.test.ts
new file mode 100644
index 000000000000..c6be4548c192
--- /dev/null
+++ b/src/test/testing/testController/common/testExecutionHandler.unit.test.ts
@@ -0,0 +1,922 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestController, TestItem, TestRun, TestMessage, Uri, Range, TestItemCollection, MarkdownString } from 'vscode';
+import * as typemoq from 'typemoq';
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { TestExecutionHandler } from '../../../../client/testing/testController/common/testExecutionHandler';
+import { TestItemIndex } from '../../../../client/testing/testController/common/testItemIndex';
+import { ExecutionTestPayload } from '../../../../client/testing/testController/common/types';
+
+suite('TestExecutionHandler', () => {
+    let executionHandler: TestExecutionHandler;
+    let testControllerMock: typemoq.IMock<TestController>;
+    let testItemIndexMock: typemoq.IMock<TestItemIndex>;
+    let runInstanceMock: typemoq.IMock<TestRun>;
+    let mockTestItem: TestItem;
+    let mockParentItem: TestItem;
+
+    setup(() => {
+        executionHandler = new TestExecutionHandler();
+        testControllerMock = typemoq.Mock.ofType<TestController>();
+        testItemIndexMock = typemoq.Mock.ofType<TestItemIndex>();
+        runInstanceMock = typemoq.Mock.ofType<TestRun>();
+
+        mockTestItem = createMockTestItem('test1', 'Test 1');
+        mockParentItem = createMockTestItem('parentTest', 'Parent Test');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    suite('processExecution', () => {
+        test('should process empty payload without errors', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {},
+                error: '',
+            };
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // No errors should be thrown
+        });
+
+        test('should process undefined result without errors', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                error: '',
+            };
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // No errors should be thrown
+        });
+
+        test('should process multiple test results', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: { test: 'test1', outcome: 'success', message: '', traceback: '' },
+                    test2: { test: 'test2', outcome: 'failure', message: 'Failed', traceback: 'traceback' },
+                },
+                error: '',
+            };
+
+            const mockTestItem2 = createMockTestItem('test2', 'Test 2');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test2', testControllerMock.object))
+                .returns(() => mockTestItem2);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.passed(mockTestItem), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.failed(mockTestItem2, typemoq.It.isAny()), typemoq.Times.once());
+        });
+    });
+
+    suite('handleTestError', () => {
+        test('should create error message with traceback', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'error',
+                        message: 'Error occurred',
+                        traceback: 'line1\nline2\nline3',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            let capturedMessage: TestMessage | undefined;
+            runInstanceMock
+                .setup((r) => r.errored(mockTestItem, typemoq.It.isAny()))
+                .callback((_, message: TestMessage) => {
+                    capturedMessage = message;
+                });
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            assert.ok(capturedMessage);
+            const messageText =
+                capturedMessage!.message instanceof MarkdownString
+                    ? capturedMessage!.message.value
+                    : capturedMessage!.message;
+            assert.ok(messageText.includes('Error occurred'));
+            assert.ok(messageText.includes('line1'));
+            assert.ok(messageText.includes('line2'));
+            runInstanceMock.verify((r) => r.errored(mockTestItem, typemoq.It.isAny()), typemoq.Times.once());
+        });
+
+        test('should set location when test item has range', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'error',
+                        message: 'Error',
+                        traceback: '',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            let capturedMessage: TestMessage | undefined;
+            runInstanceMock
+                .setup((r) => r.errored(mockTestItem, typemoq.It.isAny()))
+                .callback((_, message: TestMessage) => {
+                    capturedMessage = message;
+                });
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            assert.ok(capturedMessage);
+            assert.ok(capturedMessage!.location);
+            assert.strictEqual(capturedMessage!.location!.uri.fsPath, mockTestItem.uri!.fsPath);
+        });
+
+        test('should handle missing traceback', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'error',
+                        message: 'Error',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.errored(mockTestItem, typemoq.It.isAny()), typemoq.Times.once());
+        });
+    });
+
+    suite('handleTestFailure', () => {
+        test('should create failure message with traceback', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'failure',
+                        message: 'Assertion failed',
+                        traceback: 'AssertionError\nline1',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            let capturedMessage: TestMessage | undefined;
+            runInstanceMock
+                .setup((r) => r.failed(mockTestItem, typemoq.It.isAny()))
+                .callback((_, message: TestMessage) => {
+                    capturedMessage = message;
+                });
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            assert.ok(capturedMessage);
+            const messageText =
+                capturedMessage!.message instanceof MarkdownString
+                    ? capturedMessage!.message.value
+                    : capturedMessage!.message;
+            assert.ok(messageText.includes('Assertion failed'));
+            assert.ok(messageText.includes('AssertionError'));
+            runInstanceMock.verify((r) => r.failed(mockTestItem, typemoq.It.isAny()), typemoq.Times.once());
+        });
+
+        test('should handle passed-unexpected outcome', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'passed-unexpected',
+                        message: 'Unexpected pass',
+                        traceback: '',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.failed(mockTestItem, typemoq.It.isAny()), typemoq.Times.once());
+        });
+    });
+
+    suite('handleTestSuccess', () => {
+        test('should mark test as passed', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'success',
+                        message: '',
+                        traceback: '',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.passed(mockTestItem), typemoq.Times.once());
+        });
+
+        test('should handle expected-failure outcome', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'expected-failure',
+                        message: '',
+                        traceback: '',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.passed(mockTestItem), typemoq.Times.once());
+        });
+
+        test('should not call passed when test item not found', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'success',
+                        message: '',
+                        traceback: '',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock.setup((x) => x.getTestItem('test1', testControllerMock.object)).returns(() => undefined);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.passed(typemoq.It.isAny()), typemoq.Times.never());
+        });
+    });
+
+    suite('handleTestSkipped', () => {
+        test('should mark test as skipped', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    test1: {
+                        test: 'test1',
+                        outcome: 'skipped',
+                        message: 'Test skipped',
+                        traceback: '',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test1', testControllerMock.object))
+                .returns(() => mockTestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.skipped(mockTestItem), typemoq.Times.once());
+        });
+    });
+
+    suite('handleSubtestFailure', () => {
+        test('should create child test item for subtest', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest1)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-failure',
+                        message: 'Subtest failed',
+                        traceback: 'traceback',
+                        subtest: 'subtest1',
+                    },
+                },
+                error: '',
+            };
+
+            const mockSubtestItem = createMockTestItem('subtest1', 'Subtest 1');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => undefined);
+            testItemIndexMock
+                .setup((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()))
+                .returns(() => undefined);
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => mockSubtestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify stats were set correctly
+            testItemIndexMock.verify(
+                (x) =>
+                    x.setSubtestStats(
+                        'parentTest',
+                        typemoq.It.is((stats) => stats.failed === 1 && stats.passed === 0),
+                    ),
+                typemoq.Times.once(),
+            );
+
+            runInstanceMock.verify((r) => r.started(mockSubtestItem), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.failed(mockSubtestItem, typemoq.It.isAny()), typemoq.Times.once());
+        });
+
+        test('should update stats correctly for multiple subtests', () => {
+            const payload1: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest1)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-failure',
+                        message: 'Failed',
+                        traceback: '',
+                        subtest: 'subtest1',
+                    },
+                },
+                error: '',
+            };
+
+            const payload2: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest2)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-failure',
+                        message: 'Failed',
+                        traceback: '',
+                        subtest: 'subtest2',
+                    },
+                },
+                error: '',
+            };
+
+            const mockSubtest1 = createMockTestItem('subtest1', 'Subtest 1');
+            const mockSubtest2 = createMockTestItem('subtest2', 'Subtest 2');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+
+            // First subtest: no existing stats
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => undefined);
+            testItemIndexMock
+                .setup((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()))
+                .returns(() => undefined);
+
+            // Return different items based on call order
+            let callCount = 0;
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => {
+                    callCount++;
+                    return callCount === 1 ? mockSubtest1 : mockSubtest2;
+                });
+
+            executionHandler.processExecution(
+                payload1,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Second subtest: should have existing stats from first
+            testItemIndexMock.reset();
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => ({ failed: 1, passed: 0 }));
+
+            executionHandler.processExecution(
+                payload2,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify the first subtest set initial stats
+            runInstanceMock.verify((r) => r.started(mockSubtest1), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.started(mockSubtest2), typemoq.Times.once());
+        });
+
+        test('should throw error when parent test item not found', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest1)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-failure',
+                        message: 'Failed',
+                        traceback: '',
+                        subtest: 'subtest1',
+                    },
+                },
+                error: '',
+            };
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => undefined);
+
+            assert.throws(() => {
+                executionHandler.processExecution(
+                    payload,
+                    runInstanceMock.object,
+                    testItemIndexMock.object,
+                    testControllerMock.object,
+                );
+            }, /Parent test item not found/);
+        });
+    });
+
+    suite('handleSubtestSuccess', () => {
+        test('should create passing subtest', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest1)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-success',
+                        message: '',
+                        traceback: '',
+                        subtest: 'subtest1',
+                    },
+                },
+                error: '',
+            };
+
+            const mockSubtestItem = createMockTestItem('subtest1', 'Subtest 1');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => undefined);
+            testItemIndexMock
+                .setup((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()))
+                .returns(() => undefined);
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => mockSubtestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify stats were set correctly
+            testItemIndexMock.verify(
+                (x) =>
+                    x.setSubtestStats(
+                        'parentTest',
+                        typemoq.It.is((stats) => stats.passed === 1 && stats.failed === 0),
+                    ),
+                typemoq.Times.once(),
+            );
+
+            runInstanceMock.verify((r) => r.started(mockSubtestItem), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.passed(mockSubtestItem), typemoq.Times.once());
+        });
+
+        test('should handle subtest with special characters in name', () => {
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest [subtest with spaces and [brackets]]': {
+                        test: 'parentTest',
+                        outcome: 'subtest-success',
+                        message: '',
+                        traceback: '',
+                        subtest: 'subtest with spaces and [brackets]',
+                    },
+                },
+                error: '',
+            };
+
+            const mockSubtestItem = createMockTestItem('[subtest with spaces and [brackets]]', 'Subtest');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => undefined);
+            testItemIndexMock
+                .setup((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()))
+                .returns(() => undefined);
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => mockSubtestItem);
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            runInstanceMock.verify((r) => r.passed(mockSubtestItem), typemoq.Times.once());
+        });
+    });
+
+    suite('Comprehensive Subtest Scenarios', () => {
+        test('should handle mixed passing and failing subtests in sequence', () => {
+            // Simulates unittest with subtests like: test_even with i=0,1,2,3,4,5
+            const mockSubtest0 = createMockTestItem('(i=0)', '(i=0)');
+            const mockSubtest1 = createMockTestItem('(i=1)', '(i=1)');
+            const mockSubtest2 = createMockTestItem('(i=2)', '(i=2)');
+            const mockSubtest3 = createMockTestItem('(i=3)', '(i=3)');
+            const mockSubtest4 = createMockTestItem('(i=4)', '(i=4)');
+            const mockSubtest5 = createMockTestItem('(i=5)', '(i=5)');
+
+            const subtestItems = [mockSubtest0, mockSubtest1, mockSubtest2, mockSubtest3, mockSubtest4, mockSubtest5];
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test_even', testControllerMock.object))
+                .returns(() => mockParentItem);
+
+            let subtestCallCount = 0;
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => subtestItems[subtestCallCount++]);
+
+            // First subtest (i=0) - passes
+            testItemIndexMock.setup((x) => x.getSubtestStats('test_even')).returns(() => undefined);
+            testItemIndexMock.setup((x) => x.setSubtestStats('test_even', typemoq.It.isAny())).returns(() => undefined);
+
+            const payload0: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'test_even (i=0)': {
+                        test: 'test_even',
+                        outcome: 'subtest-success',
+                        message: '',
+                        traceback: '',
+                        subtest: '(i=0)',
+                    },
+                },
+                error: '',
+            };
+
+            executionHandler.processExecution(
+                payload0,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify first subtest created stats
+            testItemIndexMock.verify(
+                (x) =>
+                    x.setSubtestStats(
+                        'test_even',
+                        typemoq.It.is((stats) => stats.passed === 1 && stats.failed === 0),
+                    ),
+                typemoq.Times.once(),
+            );
+
+            // Second subtest (i=1) - fails
+            testItemIndexMock.reset();
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test_even', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('test_even')).returns(() => ({ passed: 1, failed: 0 }));
+
+            const payload1: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'test_even (i=1)': {
+                        test: 'test_even',
+                        outcome: 'subtest-failure',
+                        message: '1 is not even',
+                        traceback: 'AssertionError',
+                        subtest: '(i=1)',
+                    },
+                },
+                error: '',
+            };
+
+            executionHandler.processExecution(
+                payload1,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Third subtest (i=2) - passes
+            testItemIndexMock.reset();
+            testItemIndexMock
+                .setup((x) => x.getTestItem('test_even', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('test_even')).returns(() => ({ passed: 1, failed: 1 }));
+
+            const payload2: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'test_even (i=2)': {
+                        test: 'test_even',
+                        outcome: 'subtest-success',
+                        message: '',
+                        traceback: '',
+                        subtest: '(i=2)',
+                    },
+                },
+                error: '',
+            };
+
+            executionHandler.processExecution(
+                payload2,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify all subtests were started and had outcomes
+            runInstanceMock.verify((r) => r.started(mockSubtest0), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.passed(mockSubtest0), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.started(mockSubtest1), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.failed(mockSubtest1, typemoq.It.isAny()), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.started(mockSubtest2), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.passed(mockSubtest2), typemoq.Times.once());
+        });
+
+        test('should persist stats across multiple processExecution calls', () => {
+            // Test that stats persist in TestItemIndex across multiple processExecution calls
+            const mockSubtest1 = createMockTestItem('subtest1', 'Subtest 1');
+            const mockSubtest2 = createMockTestItem('subtest2', 'Subtest 2');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => undefined);
+            testItemIndexMock
+                .setup((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()))
+                .returns(() => undefined);
+
+            let callCount = 0;
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => (callCount++ === 0 ? mockSubtest1 : mockSubtest2));
+
+            const payload1: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest1)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-success',
+                        message: '',
+                        traceback: '',
+                        subtest: 'subtest1',
+                    },
+                },
+                error: '',
+            };
+
+            // First call - no existing stats
+            executionHandler.processExecution(
+                payload1,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Simulate stats being stored in TestItemIndex
+            testItemIndexMock.reset();
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => ({ passed: 1, failed: 0 }));
+
+            const payload2: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest2)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-failure',
+                        message: 'Failed',
+                        traceback: '',
+                        subtest: 'subtest2',
+                    },
+                },
+                error: '',
+            };
+
+            // Second call - existing stats should be retrieved and updated
+            executionHandler.processExecution(
+                payload2,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify getSubtestStats was called to retrieve existing stats
+            testItemIndexMock.verify((x) => x.getSubtestStats('parentTest'), typemoq.Times.once());
+
+            // Verify both subtests were processed
+            runInstanceMock.verify((r) => r.passed(mockSubtest1), typemoq.Times.once());
+            runInstanceMock.verify((r) => r.failed(mockSubtest2, typemoq.It.isAny()), typemoq.Times.once());
+        });
+
+        test('should clear children only on first subtest when no existing stats', () => {
+            // When first subtest arrives, children should be cleared
+            // Subsequent subtests should NOT clear children
+            const mockSubtest1 = createMockTestItem('subtest1', 'Subtest 1');
+
+            testItemIndexMock
+                .setup((x) => x.getTestItem('parentTest', testControllerMock.object))
+                .returns(() => mockParentItem);
+            testItemIndexMock.setup((x) => x.getSubtestStats('parentTest')).returns(() => undefined);
+            testItemIndexMock
+                .setup((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()))
+                .returns(() => undefined);
+            testControllerMock
+                .setup((t) => t.createTestItem(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()))
+                .returns(() => mockSubtest1);
+
+            const payload: ExecutionTestPayload = {
+                cwd: '/foo/bar',
+                status: 'success',
+                result: {
+                    'parentTest (subtest1)': {
+                        test: 'parentTest',
+                        outcome: 'subtest-success',
+                        message: '',
+                        traceback: '',
+                        subtest: 'subtest1',
+                    },
+                },
+                error: '',
+            };
+
+            executionHandler.processExecution(
+                payload,
+                runInstanceMock.object,
+                testItemIndexMock.object,
+                testControllerMock.object,
+            );
+
+            // Verify setSubtestStats was called (which happens when creating new stats)
+            testItemIndexMock.verify((x) => x.setSubtestStats('parentTest', typemoq.It.isAny()), typemoq.Times.once());
+        });
+    });
+});
+
+function createMockTestItem(id: string, label: string): TestItem {
+    const range = new Range(0, 0, 0, 0);
+    const mockChildren = typemoq.Mock.ofType<TestItemCollection>();
+    mockChildren.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+
+    const mockTestItem = ({
+        id,
+        label,
+        canResolveChildren: false,
+        tags: [],
+        children: mockChildren.object,
+        range,
+        uri: Uri.file('/foo/bar/test.py'),
+        parent: undefined,
+    } as unknown) as TestItem;
+
+    return mockTestItem;
+}
diff --git a/src/test/testing/testController/common/testItemIndex.unit.test.ts b/src/test/testing/testController/common/testItemIndex.unit.test.ts
new file mode 100644
index 000000000000..6712d90ff667
--- /dev/null
+++ b/src/test/testing/testController/common/testItemIndex.unit.test.ts
@@ -0,0 +1,359 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TestController, TestItem, Uri, Range, TestItemCollection } from 'vscode';
+import * as typemoq from 'typemoq';
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { TestItemIndex } from '../../../../client/testing/testController/common/testItemIndex';
+
+suite('TestItemIndex', () => {
+    let testItemIndex: TestItemIndex;
+    let testControllerMock: typemoq.IMock<TestController>;
+    let mockTestItem1: TestItem;
+    let mockTestItem2: TestItem;
+    let mockParentItem: TestItem;
+
+    setup(() => {
+        testItemIndex = new TestItemIndex();
+        testControllerMock = typemoq.Mock.ofType<TestController>();
+
+        // Create mock test items
+        mockTestItem1 = createMockTestItem('test1', 'Test 1');
+        mockTestItem2 = createMockTestItem('test2', 'Test 2');
+        mockParentItem = createMockTestItem('parent', 'Parent');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    suite('registerTestItem', () => {
+        test('should store all three mappings correctly', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'test_file.py::test_example';
+
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId), mockTestItem1);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.get(runId), vsId);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.get(vsId), runId);
+        });
+
+        test('should overwrite existing mappings', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'test_file.py::test_example';
+
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem2);
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId), mockTestItem2);
+        });
+
+        test('should handle different runId and vsId', () => {
+            const runId = 'test_file.py::TestClass::test_method';
+            const vsId = 'different_id';
+
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            assert.strictEqual(testItemIndex.runIdToVSidMap.get(runId), vsId);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.get(vsId), runId);
+        });
+    });
+
+    suite('getTestItem', () => {
+        test('should return item on direct lookup when valid', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'test_file.py::test_example';
+
+            // Register the item
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            // Mock the validation to return true
+            const isValidStub = sinon.stub(testItemIndex, 'isTestItemValid').returns(true);
+
+            const result = testItemIndex.getTestItem(runId, testControllerMock.object);
+
+            assert.strictEqual(result, mockTestItem1);
+            assert.ok(isValidStub.calledOnce);
+        });
+
+        test('should remove stale item and try vsId fallback', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'test_file.py::test_example';
+
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            // Mock validation to fail on first call (stale item)
+            const isValidStub = sinon.stub(testItemIndex, 'isTestItemValid').returns(false);
+
+            // Setup controller to not find the item
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.forEach(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.getTestItem(runId, testControllerMock.object);
+
+            // Should have removed the stale item
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId), undefined);
+            assert.strictEqual(result, undefined);
+            assert.ok(isValidStub.calledOnce);
+        });
+
+        test('should perform vsId search when direct lookup is stale', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'test_file.py::test_example';
+
+            // Create test item with correct ID
+            const searchableTestItem = createMockTestItem(vsId, 'Test Example');
+
+            testItemIndex.registerTestItem(runId, vsId, searchableTestItem);
+
+            // First validation fails (stale), need to search by vsId
+            sinon.stub(testItemIndex, 'isTestItemValid').returns(false);
+
+            // Setup controller to find item by vsId
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock
+                .setup((x) => x.forEach(typemoq.It.isAny()))
+                .callback((callback) => {
+                    callback(searchableTestItem);
+                })
+                .returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.getTestItem(runId, testControllerMock.object);
+
+            // Should recache the found item
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId), searchableTestItem);
+            assert.strictEqual(result, searchableTestItem);
+        });
+
+        test('should return undefined if not found anywhere', () => {
+            const runId = 'nonexistent';
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.forEach(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.getTestItem(runId, testControllerMock.object);
+
+            assert.strictEqual(result, undefined);
+        });
+    });
+
+    suite('getRunId and getVSId', () => {
+        test('getRunId should convert VS Code ID to Python run ID', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'vscode_id';
+
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            assert.strictEqual(testItemIndex.getRunId(vsId), runId);
+        });
+
+        test('getRunId should return undefined for unknown vsId', () => {
+            assert.strictEqual(testItemIndex.getRunId('unknown'), undefined);
+        });
+
+        test('getVSId should convert Python run ID to VS Code ID', () => {
+            const runId = 'test_file.py::test_example';
+            const vsId = 'vscode_id';
+
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            assert.strictEqual(testItemIndex.getVSId(runId), vsId);
+        });
+
+        test('getVSId should return undefined for unknown runId', () => {
+            assert.strictEqual(testItemIndex.getVSId('unknown'), undefined);
+        });
+    });
+
+    suite('clear', () => {
+        test('should remove all mappings', () => {
+            testItemIndex.registerTestItem('runId1', 'vsId1', mockTestItem1);
+            testItemIndex.registerTestItem('runId2', 'vsId2', mockTestItem2);
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.size, 2);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.size, 2);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.size, 2);
+
+            testItemIndex.clear();
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.size, 0);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.size, 0);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.size, 0);
+        });
+
+        test('should handle clearing empty index', () => {
+            testItemIndex.clear();
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.size, 0);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.size, 0);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.size, 0);
+        });
+    });
+
+    suite('isTestItemValid', () => {
+        test('should return true for item with valid parent chain leading to controller', () => {
+            const childItem = createMockTestItem('child', 'Child');
+            (childItem as any).parent = mockParentItem;
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(mockParentItem.id)).returns(() => mockParentItem);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.isTestItemValid(childItem, testControllerMock.object);
+
+            assert.strictEqual(result, true);
+        });
+
+        test('should return false for orphaned item', () => {
+            const orphanedItem = createMockTestItem('orphaned', 'Orphaned');
+            (orphanedItem as any).parent = mockParentItem;
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.isTestItemValid(orphanedItem, testControllerMock.object);
+
+            assert.strictEqual(result, false);
+        });
+
+        test('should return true for root item in controller', () => {
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(mockTestItem1.id)).returns(() => mockTestItem1);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.isTestItemValid(mockTestItem1, testControllerMock.object);
+
+            assert.strictEqual(result, true);
+        });
+
+        test('should return false for item not in controller and no parent', () => {
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock.setup((x) => x.get(typemoq.It.isAny())).returns(() => undefined);
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
+            const result = testItemIndex.isTestItemValid(mockTestItem1, testControllerMock.object);
+
+            assert.strictEqual(result, false);
+        });
+    });
+
+    suite('cleanupStaleReferences', () => {
+        test('should remove items not in controller', () => {
+            const runId1 = 'test1';
+            const runId2 = 'test2';
+            const vsId1 = 'vs1';
+            const vsId2 = 'vs2';
+
+            testItemIndex.registerTestItem(runId1, vsId1, mockTestItem1);
+            testItemIndex.registerTestItem(runId2, vsId2, mockTestItem2);
+
+            // Mock validation: first item invalid, second valid
+            const isValidStub = sinon.stub(testItemIndex, 'isTestItemValid');
+            isValidStub.onFirstCall().returns(false); // mockTestItem1 is invalid
+            isValidStub.onSecondCall().returns(true); // mockTestItem2 is valid
+
+            testItemIndex.cleanupStaleReferences(testControllerMock.object);
+
+            // First item should be removed
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId1), undefined);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.get(runId1), undefined);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.get(vsId1), undefined);
+
+            // Second item should remain
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId2), mockTestItem2);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.get(runId2), vsId2);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.get(vsId2), runId2);
+        });
+
+        test('should keep all valid items', () => {
+            const runId1 = 'test1';
+            const vsId1 = 'vs1';
+
+            testItemIndex.registerTestItem(runId1, vsId1, mockTestItem1);
+
+            sinon.stub(testItemIndex, 'isTestItemValid').returns(true);
+
+            testItemIndex.cleanupStaleReferences(testControllerMock.object);
+
+            // Item should still be there
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.get(runId1), mockTestItem1);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.get(runId1), vsId1);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.get(vsId1), runId1);
+        });
+
+        test('should handle empty index', () => {
+            testItemIndex.cleanupStaleReferences(testControllerMock.object);
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.size, 0);
+        });
+
+        test('should remove all items when all are invalid', () => {
+            testItemIndex.registerTestItem('test1', 'vs1', mockTestItem1);
+            testItemIndex.registerTestItem('test2', 'vs2', mockTestItem2);
+
+            sinon.stub(testItemIndex, 'isTestItemValid').returns(false);
+
+            testItemIndex.cleanupStaleReferences(testControllerMock.object);
+
+            assert.strictEqual(testItemIndex.runIdToTestItemMap.size, 0);
+            assert.strictEqual(testItemIndex.runIdToVSidMap.size, 0);
+            assert.strictEqual(testItemIndex.vsIdToRunIdMap.size, 0);
+        });
+    });
+
+    suite('Backward compatibility getters', () => {
+        test('runIdToTestItemMap should return the internal map', () => {
+            const runId = 'test1';
+            testItemIndex.registerTestItem(runId, 'vs1', mockTestItem1);
+
+            const map = testItemIndex.runIdToTestItemMap;
+
+            assert.strictEqual(map.get(runId), mockTestItem1);
+        });
+
+        test('runIdToVSidMap should return the internal map', () => {
+            const runId = 'test1';
+            const vsId = 'vs1';
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            const map = testItemIndex.runIdToVSidMap;
+
+            assert.strictEqual(map.get(runId), vsId);
+        });
+
+        test('vsIdToRunIdMap should return the internal map', () => {
+            const runId = 'test1';
+            const vsId = 'vs1';
+            testItemIndex.registerTestItem(runId, vsId, mockTestItem1);
+
+            const map = testItemIndex.vsIdToRunIdMap;
+
+            assert.strictEqual(map.get(vsId), runId);
+        });
+    });
+});
+
+function createMockTestItem(id: string, label: string): TestItem {
+    const range = new Range(0, 0, 0, 0);
+    const mockChildren = typemoq.Mock.ofType<TestItemCollection>();
+    mockChildren.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+
+    const mockTestItem = ({
+        id,
+        label,
+        canResolveChildren: false,
+        tags: [],
+        children: mockChildren.object,
+        range,
+        uri: Uri.file('/foo/bar'),
+        parent: undefined,
+    } as unknown) as TestItem;
+
+    return mockTestItem;
+}
diff --git a/src/test/testing/testController/common/testProjectRegistry.unit.test.ts b/src/test/testing/testController/common/testProjectRegistry.unit.test.ts
new file mode 100644
index 000000000000..5d04930d0e88
--- /dev/null
+++ b/src/test/testing/testController/common/testProjectRegistry.unit.test.ts
@@ -0,0 +1,440 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import { TestController, Uri } from 'vscode';
+import { IConfigurationService } from '../../../../client/common/types';
+import { IEnvironmentVariablesProvider } from '../../../../client/common/variables/types';
+import { IInterpreterService } from '../../../../client/interpreter/contracts';
+import { TestProjectRegistry } from '../../../../client/testing/testController/common/testProjectRegistry';
+import * as envExtApiInternal from '../../../../client/envExt/api.internal';
+import { PythonProject, PythonEnvironment } from '../../../../client/envExt/types';
+
+suite('TestProjectRegistry', () => {
+    let sandbox: sinon.SinonSandbox;
+    let testController: TestController;
+    let configSettings: IConfigurationService;
+    let interpreterService: IInterpreterService;
+    let envVarsService: IEnvironmentVariablesProvider;
+    let registry: TestProjectRegistry;
+
+    setup(() => {
+        sandbox = sinon.createSandbox();
+
+        // Create mock test controller
+        testController = ({
+            items: {
+                get: sandbox.stub(),
+                add: sandbox.stub(),
+                delete: sandbox.stub(),
+                forEach: sandbox.stub(),
+            },
+            createTestItem: sandbox.stub(),
+            dispose: sandbox.stub(),
+        } as unknown) as TestController;
+
+        // Create mock config settings
+        configSettings = ({
+            getSettings: sandbox.stub().returns({
+                testing: {
+                    pytestEnabled: true,
+                    unittestEnabled: false,
+                },
+            }),
+        } as unknown) as IConfigurationService;
+
+        // Create mock interpreter service
+        interpreterService = ({
+            getActiveInterpreter: sandbox.stub().resolves({
+                displayName: 'Python 3.11',
+                path: '/usr/bin/python3',
+                version: { raw: '3.11.8' },
+                sysPrefix: '/usr',
+            }),
+        } as unknown) as IInterpreterService;
+
+        // Create mock env vars service
+        envVarsService = ({
+            getEnvironmentVariables: sandbox.stub().resolves({}),
+        } as unknown) as IEnvironmentVariablesProvider;
+
+        registry = new TestProjectRegistry(testController, configSettings, interpreterService, envVarsService);
+    });
+
+    teardown(() => {
+        sandbox.restore();
+    });
+
+    suite('hasProjects', () => {
+        test('should return false for uninitialized workspace', () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            const result = registry.hasProjects(workspaceUri);
+
+            expect(result).to.be.false;
+        });
+
+        test('should return true after projects are registered', async () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            // Mock useEnvExtension to return false to use default project path
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+
+            const result = registry.hasProjects(workspaceUri);
+
+            expect(result).to.be.true;
+        });
+    });
+
+    suite('getProjectsArray', () => {
+        test('should return empty array for uninitialized workspace', () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            const result = registry.getProjectsArray(workspaceUri);
+
+            expect(result).to.be.an('array').that.is.empty;
+        });
+
+        test('should return projects after registration', async () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            // Mock useEnvExtension to return false to use default project path
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+
+            const result = registry.getProjectsArray(workspaceUri);
+
+            expect(result).to.be.an('array').with.length(1);
+            expect(result[0].projectUri.fsPath).to.equal(workspaceUri.fsPath);
+        });
+    });
+
+    suite('discoverAndRegisterProjects', () => {
+        test('should create default project when env extension not available', async () => {
+            const workspaceUri = Uri.file('/workspace/myproject');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            expect(projects).to.have.length(1);
+            expect(projects[0].projectUri.fsPath).to.equal(workspaceUri.fsPath);
+            expect(projects[0].testProvider).to.equal('pytest');
+        });
+
+        test('should use unittest when configured', async () => {
+            const workspaceUri = Uri.file('/workspace/myproject');
+
+            (configSettings.getSettings as sinon.SinonStub).returns({
+                testing: {
+                    pytestEnabled: false,
+                    unittestEnabled: true,
+                },
+            });
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            expect(projects).to.have.length(1);
+            expect(projects[0].testProvider).to.equal('unittest');
+        });
+
+        test('should discover projects from Python Environments API', async () => {
+            const workspaceUri = Uri.file('/workspace');
+            const projectUri = Uri.file('/workspace/project1');
+
+            const mockPythonProject: PythonProject = {
+                name: 'project1',
+                uri: projectUri,
+            };
+
+            const mockPythonEnv: PythonEnvironment = {
+                name: 'env1',
+                displayName: 'Python 3.11',
+                shortDisplayName: 'Python 3.11',
+                displayPath: '/usr/bin/python3',
+                version: '3.11.8',
+                environmentPath: Uri.file('/usr/bin/python3'),
+                sysPrefix: '/usr',
+                execInfo: { run: { executable: '/usr/bin/python3' } },
+                envId: { id: 'env1', managerId: 'manager1' },
+            };
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => [mockPythonProject],
+                getEnvironment: sandbox.stub().resolves(mockPythonEnv),
+            } as any);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            expect(projects).to.have.length(1);
+            expect(projects[0].projectName).to.include('project1');
+            expect(projects[0].pythonEnvironment).to.deep.equal(mockPythonEnv);
+        });
+
+        test('should filter projects to current workspace', async () => {
+            const workspaceUri = Uri.file('/workspace1');
+            const projectInWorkspace = Uri.file('/workspace1/project1');
+            const projectOutsideWorkspace = Uri.file('/workspace2/project2');
+
+            const mockProjects: PythonProject[] = [
+                { name: 'project1', uri: projectInWorkspace },
+                { name: 'project2', uri: projectOutsideWorkspace },
+            ];
+
+            const mockPythonEnv: PythonEnvironment = {
+                name: 'env1',
+                displayName: 'Python 3.11',
+                shortDisplayName: 'Python 3.11',
+                displayPath: '/usr/bin/python3',
+                version: '3.11.8',
+                environmentPath: Uri.file('/usr/bin/python3'),
+                sysPrefix: '/usr',
+                execInfo: { run: { executable: '/usr/bin/python3' } },
+                envId: { id: 'env1', managerId: 'manager1' },
+            };
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => mockProjects,
+                getEnvironment: sandbox.stub().resolves(mockPythonEnv),
+            } as any);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            expect(projects).to.have.length(1);
+            expect(projects[0].projectUri.fsPath).to.equal(projectInWorkspace.fsPath);
+        });
+
+        test('should fallback to default project when no projects found', async () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => [],
+            } as any);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            expect(projects).to.have.length(1);
+            expect(projects[0].projectUri.fsPath).to.equal(workspaceUri.fsPath);
+        });
+
+        test('should fallback to default project on API error', async () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').rejects(new Error('API error'));
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            expect(projects).to.have.length(1);
+            expect(projects[0].projectUri.fsPath).to.equal(workspaceUri.fsPath);
+        });
+    });
+
+    suite('configureNestedProjectIgnores', () => {
+        test('should not set ignores when no nested projects', async () => {
+            const workspaceUri = Uri.file('/workspace');
+            const projectUri = Uri.file('/workspace/project1');
+
+            const mockPythonProject: PythonProject = {
+                name: 'project1',
+                uri: projectUri,
+            };
+
+            const mockPythonEnv: PythonEnvironment = {
+                name: 'env1',
+                displayName: 'Python 3.11',
+                shortDisplayName: 'Python 3.11',
+                displayPath: '/usr/bin/python3',
+                version: '3.11.8',
+                environmentPath: Uri.file('/usr/bin/python3'),
+                sysPrefix: '/usr',
+                execInfo: { run: { executable: '/usr/bin/python3' } },
+                envId: { id: 'env1', managerId: 'manager1' },
+            };
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => [mockPythonProject],
+                getEnvironment: sandbox.stub().resolves(mockPythonEnv),
+            } as any);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+            registry.configureNestedProjectIgnores(workspaceUri);
+
+            const projects = registry.getProjectsArray(workspaceUri);
+            expect(projects[0].nestedProjectPathsToIgnore).to.be.undefined;
+        });
+
+        test('should configure ignore paths for nested projects', async () => {
+            const workspaceUri = Uri.file('/workspace');
+            const parentProjectUri = Uri.file('/workspace/parent');
+            const childProjectUri = Uri.file(path.join('/workspace/parent', 'child'));
+
+            const mockProjects: PythonProject[] = [
+                { name: 'parent', uri: parentProjectUri },
+                { name: 'child', uri: childProjectUri },
+            ];
+
+            const mockPythonEnv: PythonEnvironment = {
+                name: 'env1',
+                displayName: 'Python 3.11',
+                shortDisplayName: 'Python 3.11',
+                displayPath: '/usr/bin/python3',
+                version: '3.11.8',
+                environmentPath: Uri.file('/usr/bin/python3'),
+                sysPrefix: '/usr',
+                execInfo: { run: { executable: '/usr/bin/python3' } },
+                envId: { id: 'env1', managerId: 'manager1' },
+            };
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => mockProjects,
+                getEnvironment: sandbox.stub().resolves(mockPythonEnv),
+            } as any);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+            registry.configureNestedProjectIgnores(workspaceUri);
+
+            const projects = registry.getProjectsArray(workspaceUri);
+            const parentProject = projects.find((p) => p.projectUri.fsPath === parentProjectUri.fsPath);
+
+            expect(parentProject?.nestedProjectPathsToIgnore).to.include(childProjectUri.fsPath);
+        });
+
+        test('should not set child project as ignored for sibling projects', async () => {
+            const workspaceUri = Uri.file('/workspace');
+            const project1Uri = Uri.file('/workspace/project1');
+            const project2Uri = Uri.file('/workspace/project2');
+
+            const mockProjects: PythonProject[] = [
+                { name: 'project1', uri: project1Uri },
+                { name: 'project2', uri: project2Uri },
+            ];
+
+            const mockPythonEnv: PythonEnvironment = {
+                name: 'env1',
+                displayName: 'Python 3.11',
+                shortDisplayName: 'Python 3.11',
+                displayPath: '/usr/bin/python3',
+                version: '3.11.8',
+                environmentPath: Uri.file('/usr/bin/python3'),
+                sysPrefix: '/usr',
+                execInfo: { run: { executable: '/usr/bin/python3' } },
+                envId: { id: 'env1', managerId: 'manager1' },
+            };
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => mockProjects,
+                getEnvironment: sandbox.stub().resolves(mockPythonEnv),
+            } as any);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+            registry.configureNestedProjectIgnores(workspaceUri);
+
+            const projects = registry.getProjectsArray(workspaceUri);
+            projects.forEach((project) => {
+                expect(project.nestedProjectPathsToIgnore).to.be.undefined;
+            });
+        });
+    });
+
+    suite('clearWorkspace', () => {
+        test('should remove all projects for a workspace', async () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+            expect(registry.hasProjects(workspaceUri)).to.be.true;
+
+            registry.clearWorkspace(workspaceUri);
+
+            expect(registry.hasProjects(workspaceUri)).to.be.false;
+            expect(registry.getProjectsArray(workspaceUri)).to.be.empty;
+        });
+
+        test('should not affect other workspaces', async () => {
+            const workspace1Uri = Uri.file('/workspace1');
+            const workspace2Uri = Uri.file('/workspace2');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            await registry.discoverAndRegisterProjects(workspace1Uri);
+            await registry.discoverAndRegisterProjects(workspace2Uri);
+
+            registry.clearWorkspace(workspace1Uri);
+
+            expect(registry.hasProjects(workspace1Uri)).to.be.false;
+            expect(registry.hasProjects(workspace2Uri)).to.be.true;
+        });
+    });
+
+    suite('getWorkspaceProjects', () => {
+        test('should return undefined for uninitialized workspace', () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            const result = registry.getWorkspaceProjects(workspaceUri);
+
+            expect(result).to.be.undefined;
+        });
+
+        test('should return map after registration', async () => {
+            const workspaceUri = Uri.file('/workspace');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            await registry.discoverAndRegisterProjects(workspaceUri);
+
+            const result = registry.getWorkspaceProjects(workspaceUri);
+
+            expect(result).to.be.instanceOf(Map);
+            expect(result?.size).to.equal(1);
+        });
+    });
+
+    suite('ProjectAdapter properties', () => {
+        test('should create adapter with correct test infrastructure', async () => {
+            const workspaceUri = Uri.file('/workspace/myproject');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+            const project = projects[0];
+
+            expect(project.projectName).to.be.a('string');
+            expect(project.projectUri.fsPath).to.equal(workspaceUri.fsPath);
+            expect(project.workspaceUri.fsPath).to.equal(workspaceUri.fsPath);
+            expect(project.testProvider).to.equal('pytest');
+            expect(project.discoveryAdapter).to.exist;
+            expect(project.executionAdapter).to.exist;
+            expect(project.resultResolver).to.exist;
+            expect(project.isDiscovering).to.be.false;
+            expect(project.isExecuting).to.be.false;
+        });
+
+        test('should include python environment details', async () => {
+            const workspaceUri = Uri.file('/workspace/myproject');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+            const project = projects[0];
+
+            expect(project.pythonEnvironment).to.exist;
+            expect(project.pythonProject).to.exist;
+            expect(project.pythonProject.name).to.equal('myproject');
+        });
+    });
+});
diff --git a/src/test/testing/testController/controller.unit.test.ts b/src/test/testing/testController/controller.unit.test.ts
new file mode 100644
index 000000000000..feb5f36fc797
--- /dev/null
+++ b/src/test/testing/testController/controller.unit.test.ts
@@ -0,0 +1,344 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+import { TestController, Uri } from 'vscode';
+
+import { PYTEST_PROVIDER, UNITTEST_PROVIDER } from '../../../client/testing/common/constants';
+import * as envExtApiInternal from '../../../client/envExt/api.internal';
+import * as projectUtils from '../../../client/testing/testController/common/projectUtils';
+import { PythonTestController } from '../../../client/testing/testController/controller';
+import { TestProjectRegistry } from '../../../client/testing/testController/common/testProjectRegistry';
+
+function createStubTestController(): TestController {
+    const disposable = { dispose: () => undefined };
+
+    const controller = ({
+        items: {
+            forEach: sinon.stub(),
+            get: sinon.stub(),
+            add: sinon.stub(),
+            replace: sinon.stub(),
+            delete: sinon.stub(),
+            size: 0,
+            [Symbol.iterator]: sinon.stub(),
+        },
+        createRunProfile: sinon.stub().returns(disposable),
+        createTestItem: sinon.stub(),
+        dispose: sinon.stub(),
+        resolveHandler: undefined,
+        refreshHandler: undefined,
+    } as unknown) as TestController;
+
+    return controller;
+}
+
+suite('PythonTestController', () => {
+    let sandbox: sinon.SinonSandbox;
+
+    setup(() => {
+        sandbox = sinon.createSandbox();
+    });
+
+    teardown(() => {
+        sandbox.restore();
+    });
+
+    function createController(options?: { unittestEnabled?: boolean; interpreter?: any }): any {
+        const unittestEnabled = options?.unittestEnabled ?? false;
+        const interpreter =
+            options?.interpreter ??
+            ({
+                displayName: 'Python 3.11',
+                path: '/usr/bin/python3',
+                version: { raw: '3.11.8' },
+                sysPrefix: '/usr',
+            } as any);
+
+        const workspaceService = ({ workspaceFolders: [] } as unknown) as any;
+        const configSettings = ({
+            getSettings: sandbox.stub().returns({
+                testing: {
+                    unittestEnabled,
+                    autoTestDiscoverOnSaveEnabled: false,
+                },
+            }),
+        } as unknown) as any;
+
+        const pytest = ({} as unknown) as any;
+        const unittest = ({} as unknown) as any;
+        const disposables: any[] = [];
+        const interpreterService = ({
+            getActiveInterpreter: sandbox.stub().resolves(interpreter),
+        } as unknown) as any;
+
+        const commandManager = ({
+            registerCommand: sandbox.stub().returns({ dispose: () => undefined }),
+        } as unknown) as any;
+        const pythonExecFactory = ({} as unknown) as any;
+        const debugLauncher = ({} as unknown) as any;
+        const envVarsService = ({} as unknown) as any;
+
+        return new PythonTestController(
+            workspaceService,
+            configSettings,
+            pytest,
+            unittest,
+            disposables,
+            interpreterService,
+            commandManager,
+            pythonExecFactory,
+            debugLauncher,
+            envVarsService,
+        );
+    }
+
+    suite('getTestProvider', () => {
+        test('returns unittest when enabled', () => {
+            const controller = createController({ unittestEnabled: true });
+            const workspaceUri: Uri = vscode.Uri.file('/workspace');
+
+            const provider = (controller as any).getTestProvider(workspaceUri);
+
+            assert.strictEqual(provider, UNITTEST_PROVIDER);
+        });
+
+        test('returns pytest when unittest not enabled', () => {
+            const controller = createController({ unittestEnabled: false });
+            const workspaceUri: Uri = vscode.Uri.file('/workspace');
+
+            const provider = (controller as any).getTestProvider(workspaceUri);
+
+            assert.strictEqual(provider, PYTEST_PROVIDER);
+        });
+    });
+
+    suite('createDefaultProject (via TestProjectRegistry)', () => {
+        test('creates a single default project using active interpreter', async () => {
+            const workspaceUri: Uri = vscode.Uri.file('/workspace/myws');
+            const interpreter = {
+                displayName: 'My Python',
+                path: '/opt/py/bin/python',
+                version: { raw: '3.12.1' },
+                sysPrefix: '/opt/py',
+            };
+
+            const fakeDiscoveryAdapter = { kind: 'discovery' };
+            const fakeExecutionAdapter = { kind: 'execution' };
+            sandbox.stub(projectUtils, 'createTestAdapters').returns({
+                discoveryAdapter: fakeDiscoveryAdapter,
+                executionAdapter: fakeExecutionAdapter,
+            } as any);
+
+            // Stub useEnvExtension to return false so createDefaultProject is called
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+
+            const interpreterService = {
+                getActiveInterpreter: sandbox.stub().resolves(interpreter),
+            } as any;
+
+            const configSettings = {
+                getSettings: sandbox.stub().returns({
+                    testing: { unittestEnabled: false },
+                }),
+            } as any;
+
+            const testController = createStubTestController();
+            const envVarsService = {} as any;
+
+            const registry = new TestProjectRegistry(
+                testController,
+                configSettings,
+                interpreterService,
+                envVarsService,
+            );
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+            const project = projects[0];
+
+            assert.strictEqual(projects.length, 1);
+            assert.strictEqual(project.workspaceUri.toString(), workspaceUri.toString());
+            assert.strictEqual(project.projectUri.toString(), workspaceUri.toString());
+            assert.strictEqual(project.projectName, 'myws');
+
+            assert.strictEqual(project.testProvider, PYTEST_PROVIDER);
+            assert.strictEqual(project.discoveryAdapter, fakeDiscoveryAdapter);
+            assert.strictEqual(project.executionAdapter, fakeExecutionAdapter);
+
+            assert.strictEqual(project.pythonProject.uri.toString(), workspaceUri.toString());
+            assert.strictEqual(project.pythonProject.name, 'myws');
+
+            assert.strictEqual(project.pythonEnvironment.displayName, 'My Python');
+            assert.strictEqual(project.pythonEnvironment.version, '3.12.1');
+            assert.strictEqual(project.pythonEnvironment.execInfo.run.executable, '/opt/py/bin/python');
+        });
+    });
+
+    suite('discoverWorkspaceProjects (via TestProjectRegistry)', () => {
+        test('respects useEnvExtension() == false and falls back to single default project', async () => {
+            const workspaceUri: Uri = vscode.Uri.file('/workspace/a');
+
+            const useEnvExtensionStub = sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(false);
+            const getEnvExtApiStub = sandbox.stub(envExtApiInternal, 'getEnvExtApi');
+
+            const fakeDiscoveryAdapter = { kind: 'discovery' };
+            const fakeExecutionAdapter = { kind: 'execution' };
+            sandbox.stub(projectUtils, 'createTestAdapters').returns({
+                discoveryAdapter: fakeDiscoveryAdapter,
+                executionAdapter: fakeExecutionAdapter,
+            } as any);
+
+            const interpreterService = {
+                getActiveInterpreter: sandbox.stub().resolves({
+                    displayName: 'Python 3.11',
+                    path: '/usr/bin/python3',
+                    version: { raw: '3.11.8' },
+                    sysPrefix: '/usr',
+                }),
+            } as any;
+
+            const configSettings = {
+                getSettings: sandbox.stub().returns({
+                    testing: { unittestEnabled: false },
+                }),
+            } as any;
+
+            const testController = createStubTestController();
+            const envVarsService = {} as any;
+
+            const registry = new TestProjectRegistry(
+                testController,
+                configSettings,
+                interpreterService,
+                envVarsService,
+            );
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            assert.strictEqual(useEnvExtensionStub.called, true);
+            assert.strictEqual(getEnvExtApiStub.notCalled, true);
+            assert.strictEqual(projects.length, 1);
+            assert.strictEqual(projects[0].projectUri.toString(), workspaceUri.toString());
+        });
+
+        test('filters Python projects to workspace and creates adapters for each', async () => {
+            const workspaceUri: Uri = vscode.Uri.file('/workspace/root');
+
+            const pythonProjects = [
+                { name: 'p1', uri: vscode.Uri.file('/workspace/root/p1') },
+                { name: 'p2', uri: vscode.Uri.file('/workspace/root/nested/p2') },
+                { name: 'other', uri: vscode.Uri.file('/other/root/p3') },
+            ];
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => pythonProjects,
+                getEnvironment: sandbox.stub().resolves({
+                    name: 'env',
+                    displayName: 'Python 3.11',
+                    shortDisplayName: 'Python 3.11',
+                    displayPath: '/usr/bin/python3',
+                    version: '3.11.8',
+                    environmentPath: vscode.Uri.file('/usr/bin/python3'),
+                    sysPrefix: '/usr',
+                    execInfo: { run: { executable: '/usr/bin/python3' } },
+                    envId: { id: 'test', managerId: 'test' },
+                }),
+            } as any);
+
+            const fakeDiscoveryAdapter = { kind: 'discovery' };
+            const fakeExecutionAdapter = { kind: 'execution' };
+            sandbox.stub(projectUtils, 'createTestAdapters').returns({
+                discoveryAdapter: fakeDiscoveryAdapter,
+                executionAdapter: fakeExecutionAdapter,
+            } as any);
+
+            const interpreterService = {
+                getActiveInterpreter: sandbox.stub().resolves(null),
+            } as any;
+
+            const configSettings = {
+                getSettings: sandbox.stub().returns({
+                    testing: { unittestEnabled: false },
+                }),
+            } as any;
+
+            const testController = createStubTestController();
+            const envVarsService = {} as any;
+
+            const registry = new TestProjectRegistry(
+                testController,
+                configSettings,
+                interpreterService,
+                envVarsService,
+            );
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            // Should only create adapters for the 2 projects in the workspace (not 'other')
+            assert.strictEqual(projects.length, 2);
+            const projectUris = projects.map((p: { projectUri: { fsPath: string } }) => p.projectUri.fsPath);
+            const expectedInWorkspace = [
+                vscode.Uri.file('/workspace/root/p1').fsPath,
+                vscode.Uri.file('/workspace/root/nested/p2').fsPath,
+            ];
+            const expectedOutOfWorkspace = vscode.Uri.file('/other/root/p3').fsPath;
+
+            expectedInWorkspace.forEach((expectedPath) => {
+                assert.ok(projectUris.includes(expectedPath));
+            });
+            assert.ok(!projectUris.includes(expectedOutOfWorkspace));
+        });
+
+        test('falls back to default project when no projects are in the workspace', async () => {
+            const workspaceUri: Uri = vscode.Uri.file('/workspace/root');
+
+            sandbox.stub(envExtApiInternal, 'useEnvExtension').returns(true);
+            sandbox.stub(envExtApiInternal, 'getEnvExtApi').resolves({
+                getPythonProjects: () => [{ name: 'other', uri: vscode.Uri.file('/other/root/p3') }],
+            } as any);
+
+            const fakeDiscoveryAdapter = { kind: 'discovery' };
+            const fakeExecutionAdapter = { kind: 'execution' };
+            sandbox.stub(projectUtils, 'createTestAdapters').returns({
+                discoveryAdapter: fakeDiscoveryAdapter,
+                executionAdapter: fakeExecutionAdapter,
+            } as any);
+
+            const interpreter = {
+                displayName: 'Python 3.11',
+                path: '/usr/bin/python3',
+                version: { raw: '3.11.8' },
+                sysPrefix: '/usr',
+            };
+
+            const interpreterService = {
+                getActiveInterpreter: sandbox.stub().resolves(interpreter),
+            } as any;
+
+            const configSettings = {
+                getSettings: sandbox.stub().returns({
+                    testing: { unittestEnabled: false },
+                }),
+            } as any;
+
+            const testController = createStubTestController();
+            const envVarsService = {} as any;
+
+            const registry = new TestProjectRegistry(
+                testController,
+                configSettings,
+                interpreterService,
+                envVarsService,
+            );
+
+            const projects = await registry.discoverAndRegisterProjects(workspaceUri);
+
+            // Should fall back to default project since no projects are in the workspace
+            assert.strictEqual(projects.length, 1);
+            assert.strictEqual(projects[0].projectUri.toString(), workspaceUri.toString());
+        });
+    });
+});
diff --git a/src/test/testing/testController/pytest/pytestDiscoveryAdapter.unit.test.ts b/src/test/testing/testController/pytest/pytestDiscoveryAdapter.unit.test.ts
index 157134cdf276..ec155ee3107d 100644
--- a/src/test/testing/testController/pytest/pytestDiscoveryAdapter.unit.test.ts
+++ b/src/test/testing/testController/pytest/pytestDiscoveryAdapter.unit.test.ts
@@ -8,7 +8,7 @@ import * as path from 'path';
 import { Observable } from 'rxjs/Observable';
 import * as fs from 'fs';
 import * as sinon from 'sinon';
-import { IConfigurationService, ITestOutputChannel } from '../../../../client/common/types';
+import { IConfigurationService } from '../../../../client/common/types';
 import { PytestTestDiscoveryAdapter } from '../../../../client/testing/testController/pytest/pytestDiscoveryAdapter';
 import {
     IPythonExecutionFactory,
@@ -29,7 +29,6 @@ suite('pytest test discovery adapter', () => {
     let adapter: PytestTestDiscoveryAdapter;
     let execService: typeMoq.IMock<IPythonExecutionService>;
     let deferred: Deferred<void>;
-    let outputChannel: typeMoq.IMock<ITestOutputChannel>;
     let expectedPath: string;
     let uri: Uri;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -72,7 +71,6 @@ suite('pytest test discovery adapter', () => {
         execService = typeMoq.Mock.ofType<IPythonExecutionService>();
         execService.setup((p) => ((p as unknown) as any).then).returns(() => undefined);
         execService.setup((x) => x.getExecutablePath()).returns(() => Promise.resolve('/mock/path/to/python'));
-        outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
 
         const output = new Observable<Output<string>>(() => {
             /* no op */
@@ -117,7 +115,7 @@ suite('pytest test discovery adapter', () => {
         );
         sinon.stub(fs.promises, 'realpath').callsFake(async (pathEntered) => pathEntered.toString());
 
-        adapter = new PytestTestDiscoveryAdapter(configService, outputChannel.object);
+        adapter = new PytestTestDiscoveryAdapter(configService);
         adapter.discoverTests(uri, execFactory.object);
         // add in await and trigger
         await deferred.promise;
@@ -175,7 +173,7 @@ suite('pytest test discovery adapter', () => {
                 return Promise.resolve(execService.object);
             });
 
-        adapter = new PytestTestDiscoveryAdapter(configServiceNew, outputChannel.object);
+        adapter = new PytestTestDiscoveryAdapter(configServiceNew);
         adapter.discoverTests(uri, execFactory.object);
         // add in await and trigger
         await deferred.promise;
@@ -239,7 +237,7 @@ suite('pytest test discovery adapter', () => {
                 return Promise.resolve(execService.object);
             });
 
-        adapter = new PytestTestDiscoveryAdapter(configServiceNew, outputChannel.object);
+        adapter = new PytestTestDiscoveryAdapter(configServiceNew);
         adapter.discoverTests(uri, execFactory.object);
         // add in await and trigger
         await deferred.promise;
@@ -307,7 +305,7 @@ suite('pytest test discovery adapter', () => {
                 return Promise.resolve(execService.object);
             });
 
-        adapter = new PytestTestDiscoveryAdapter(configServiceNew, outputChannel.object);
+        adapter = new PytestTestDiscoveryAdapter(configServiceNew);
         adapter.discoverTests(uri, execFactory.object);
         // add in await and trigger
         await deferred.promise;
@@ -356,7 +354,7 @@ suite('pytest test discovery adapter', () => {
         );
         sinon.stub(fs.promises, 'realpath').callsFake(async (pathEntered) => pathEntered.toString());
 
-        adapter = new PytestTestDiscoveryAdapter(configService, outputChannel.object);
+        adapter = new PytestTestDiscoveryAdapter(configService);
         const discoveryPromise = adapter.discoverTests(uri, execFactory.object, cancellationTokenSource.token);
 
         // Trigger cancellation before exec observable call finishes
@@ -406,7 +404,7 @@ suite('pytest test discovery adapter', () => {
         );
         sinon.stub(fs.promises, 'realpath').callsFake(async (pathEntered) => pathEntered.toString());
 
-        adapter = new PytestTestDiscoveryAdapter(configService, outputChannel.object);
+        adapter = new PytestTestDiscoveryAdapter(configService);
         const discoveryPromise = adapter.discoverTests(uri, execFactory.object, cancellationTokenSource.token);
 
         // add in await and trigger
diff --git a/src/test/testing/testController/pytest/pytestExecutionAdapter.unit.test.ts b/src/test/testing/testController/pytest/pytestExecutionAdapter.unit.test.ts
index 413c0af9406d..40c701b22641 100644
--- a/src/test/testing/testController/pytest/pytestExecutionAdapter.unit.test.ts
+++ b/src/test/testing/testController/pytest/pytestExecutionAdapter.unit.test.ts
@@ -7,7 +7,7 @@ import * as typeMoq from 'typemoq';
 import * as sinon from 'sinon';
 import * as path from 'path';
 import { Observable } from 'rxjs/Observable';
-import { IConfigurationService, ITestOutputChannel } from '../../../../client/common/types';
+import { IConfigurationService } from '../../../../client/common/types';
 import {
     IPythonExecutionFactory,
     IPythonExecutionService,
@@ -22,6 +22,7 @@ import { EXTENSION_ROOT_DIR } from '../../../../client/constants';
 import { MockChildProcess } from '../../../mocks/mockChildProcess';
 import { traceInfo } from '../../../../client/logging';
 import * as extapi from '../../../../client/envExt/api.internal';
+import { createMockProjectAdapter } from '../testMocks';
 
 suite('pytest test execution adapter', () => {
     let useEnvExtensionStub: sinon.SinonStub;
@@ -117,8 +118,7 @@ suite('pytest test execution adapter', () => {
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new PytestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new PytestTestExecutionAdapter(configService);
         const testIds = ['test1id', 'test2id'];
 
         adapter.runTests(uri, testIds, TestRunProfileKind.Run, testRun.object, execFactory.object);
@@ -148,8 +148,7 @@ suite('pytest test execution adapter', () => {
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new PytestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new PytestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Run, testRun.object, execFactory.object);
 
         await deferred2.promise;
@@ -207,8 +206,7 @@ suite('pytest test execution adapter', () => {
             isTestExecution: () => false,
         } as unknown) as IConfigurationService;
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new PytestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new PytestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Run, testRun.object, execFactory.object);
 
         await deferred2.promise;
@@ -263,8 +261,7 @@ suite('pytest test execution adapter', () => {
                     } as any),
             );
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new PytestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new PytestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Debug, testRun.object, execFactory.object, debugLauncher.object);
         await deferred3.promise;
         debugLauncher.verify(
@@ -305,8 +302,7 @@ suite('pytest test execution adapter', () => {
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new PytestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new PytestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Coverage, testRun.object, execFactory.object);
 
         await deferred2.promise;
@@ -330,4 +326,210 @@ suite('pytest test execution adapter', () => {
             typeMoq.Times.once(),
         );
     });
+
+    // ===== PROJECT-BASED EXECUTION TESTS =====
+
+    suite('project-based execution', () => {
+        test('should set PROJECT_ROOT_PATH env var when project provided', async () => {
+            const deferred2 = createDeferred();
+            const deferred3 = createDeferred();
+            execFactory = typeMoq.Mock.ofType<IPythonExecutionFactory>();
+            execFactory
+                .setup((x) => x.createActivatedEnvironment(typeMoq.It.isAny()))
+                .returns(() => {
+                    deferred2.resolve();
+                    return Promise.resolve(execService.object);
+                });
+            utilsWriteTestIdsFileStub.callsFake(() => {
+                deferred3.resolve();
+                return Promise.resolve('testIdPipe-mockName');
+            });
+            const testRun = typeMoq.Mock.ofType<TestRun>();
+            testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
+
+            const projectPath = path.join('/', 'workspace', 'myproject');
+            const mockProject = createMockProjectAdapter({
+                projectPath,
+                projectName: 'myproject',
+                pythonPath: '/custom/python/path',
+            });
+
+            const uri = Uri.file(myTestPath);
+            adapter = new PytestTestExecutionAdapter(configService);
+            adapter.runTests(
+                uri,
+                [],
+                TestRunProfileKind.Run,
+                testRun.object,
+                execFactory.object,
+                undefined,
+                undefined,
+                mockProject,
+            );
+
+            await deferred2.promise;
+            await deferred3.promise;
+            await deferred4.promise;
+            mockProc.trigger('close');
+
+            execService.verify(
+                (x) =>
+                    x.execObservable(
+                        typeMoq.It.isAny(),
+                        typeMoq.It.is<SpawnOptions>((options) => {
+                            assert.equal(options.env?.PROJECT_ROOT_PATH, projectPath);
+                            return true;
+                        }),
+                    ),
+                typeMoq.Times.once(),
+            );
+        });
+
+        test('should pass debugSessionName in LaunchOptions for debug mode with project', async () => {
+            const deferred3 = createDeferred();
+            utilsWriteTestIdsFileStub.callsFake(() => Promise.resolve('testIdPipe-mockName'));
+
+            debugLauncher
+                .setup((dl) => dl.launchDebugger(typeMoq.It.isAny(), typeMoq.It.isAny(), typeMoq.It.isAny()))
+                .returns(async (_opts, callback) => {
+                    traceInfo('stubs launch debugger');
+                    if (typeof callback === 'function') {
+                        deferred3.resolve();
+                        callback();
+                    }
+                });
+
+            const testRun = typeMoq.Mock.ofType<TestRun>();
+            testRun
+                .setup((t) => t.token)
+                .returns(
+                    () =>
+                        ({
+                            onCancellationRequested: () => undefined,
+                        } as any),
+                );
+
+            const projectPath = path.join('/', 'workspace', 'myproject');
+            const mockProject = createMockProjectAdapter({
+                projectPath,
+                projectName: 'myproject (Python 3.11)',
+                pythonPath: '/custom/python/path',
+            });
+
+            const uri = Uri.file(myTestPath);
+            adapter = new PytestTestExecutionAdapter(configService);
+            adapter.runTests(
+                uri,
+                [],
+                TestRunProfileKind.Debug,
+                testRun.object,
+                execFactory.object,
+                debugLauncher.object,
+                undefined,
+                mockProject,
+            );
+
+            await deferred3.promise;
+
+            debugLauncher.verify(
+                (x) =>
+                    x.launchDebugger(
+                        typeMoq.It.is<LaunchOptions>((launchOptions) => {
+                            // Project should be passed for project-based debugging
+                            assert.ok(launchOptions.project, 'project should be defined');
+                            assert.equal(launchOptions.project?.name, 'myproject (Python 3.11)');
+                            assert.equal(launchOptions.project?.uri.fsPath, projectPath);
+                            return true;
+                        }),
+                        typeMoq.It.isAny(),
+                        typeMoq.It.isAny(),
+                    ),
+                typeMoq.Times.once(),
+            );
+        });
+
+        test('should not set PROJECT_ROOT_PATH when no project provided', async () => {
+            const deferred2 = createDeferred();
+            const deferred3 = createDeferred();
+            execFactory = typeMoq.Mock.ofType<IPythonExecutionFactory>();
+            execFactory
+                .setup((x) => x.createActivatedEnvironment(typeMoq.It.isAny()))
+                .returns(() => {
+                    deferred2.resolve();
+                    return Promise.resolve(execService.object);
+                });
+            utilsWriteTestIdsFileStub.callsFake(() => {
+                deferred3.resolve();
+                return Promise.resolve('testIdPipe-mockName');
+            });
+            const testRun = typeMoq.Mock.ofType<TestRun>();
+            testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
+
+            const uri = Uri.file(myTestPath);
+            adapter = new PytestTestExecutionAdapter(configService);
+            // Call without project parameter
+            adapter.runTests(uri, [], TestRunProfileKind.Run, testRun.object, execFactory.object);
+
+            await deferred2.promise;
+            await deferred3.promise;
+            await deferred4.promise;
+            mockProc.trigger('close');
+
+            execService.verify(
+                (x) =>
+                    x.execObservable(
+                        typeMoq.It.isAny(),
+                        typeMoq.It.is<SpawnOptions>((options) => {
+                            assert.equal(options.env?.PROJECT_ROOT_PATH, undefined);
+                            return true;
+                        }),
+                    ),
+                typeMoq.Times.once(),
+            );
+        });
+
+        test('should not set project in LaunchOptions when no project provided', async () => {
+            const deferred3 = createDeferred();
+            utilsWriteTestIdsFileStub.callsFake(() => Promise.resolve('testIdPipe-mockName'));
+
+            debugLauncher
+                .setup((dl) => dl.launchDebugger(typeMoq.It.isAny(), typeMoq.It.isAny(), typeMoq.It.isAny()))
+                .returns(async (_opts, callback) => {
+                    if (typeof callback === 'function') {
+                        deferred3.resolve();
+                        callback();
+                    }
+                });
+
+            const testRun = typeMoq.Mock.ofType<TestRun>();
+            testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
+
+            const uri = Uri.file(myTestPath);
+            adapter = new PytestTestExecutionAdapter(configService);
+            // Call without project parameter
+            adapter.runTests(
+                uri,
+                [],
+                TestRunProfileKind.Debug,
+                testRun.object,
+                execFactory.object,
+                debugLauncher.object,
+            );
+
+            await deferred3.promise;
+
+            debugLauncher.verify(
+                (x) =>
+                    x.launchDebugger(
+                        typeMoq.It.is<LaunchOptions>((launchOptions) => {
+                            assert.equal(launchOptions.project, undefined);
+                            return true;
+                        }),
+                        typeMoq.It.isAny(),
+                        typeMoq.It.isAny(),
+                    ),
+                typeMoq.Times.once(),
+            );
+        });
+    });
 });
diff --git a/src/test/testing/testController/resultResolver.unit.test.ts b/src/test/testing/testController/resultResolver.unit.test.ts
index 05d2ee1dd0f3..e4b350a20750 100644
--- a/src/test/testing/testController/resultResolver.unit.test.ts
+++ b/src/test/testing/testController/resultResolver.unit.test.ts
@@ -93,12 +93,13 @@ suite('Result Resolver tests', () => {
             // assert the stub functions were called with the correct parameters
 
             // header of populateTestTree is (testController: TestController, testTreeData: DiscoveredTestNode, testRoot: TestItem | undefined, resultResolver: ITestResultResolver, token?: CancellationToken)
+            // After refactor, an inline object with testItemIndex maps is passed instead of resultResolver
             sinon.assert.calledWithMatch(
                 populateTestTreeStub,
                 testController, // testController
                 tests, // testTreeData
                 undefined, // testRoot
-                resultResolver, // resultResolver
+                sinon.match.has('runIdToTestItem'), // inline object with maps
                 cancelationToken, // token
             );
         });
@@ -182,12 +183,13 @@ suite('Result Resolver tests', () => {
             sinon.assert.calledWithMatch(createErrorTestItemStub, sinon.match.any, sinon.match.any);
 
             // also calls populateTestTree with the discovery test results
+            // After refactor, an inline object with testItemIndex maps is passed instead of resultResolver
             sinon.assert.calledWithMatch(
                 populateTestTreeStub,
                 testController, // testController
                 tests, // testTreeData
                 undefined, // testRoot
-                resultResolver, // resultResolver
+                sinon.match.has('runIdToTestItem'), // inline object with maps
                 cancelationToken, // token
             );
         });
@@ -327,6 +329,34 @@ suite('Result Resolver tests', () => {
             sinon.stub(testItemUtilities, 'clearAllChildren').callsFake(() => undefined);
             testProvider = 'unittest';
             workspaceUri = Uri.file('/foo/bar');
+
+            // Create parent test item with correct ID
+            const mockParentItem = createMockTestItem('parentTest');
+
+            // Update testControllerMock to include parent item in its collection
+            const mockTestItems: [string, TestItem][] = [
+                ['1', mockTestItem1],
+                ['2', mockTestItem2],
+                ['parentTest', mockParentItem],
+            ];
+            const iterableMock = mockTestItems[Symbol.iterator]();
+
+            const testItemCollectionMock = typemoq.Mock.ofType<TestItemCollection>();
+            testItemCollectionMock
+                .setup((x) => x.forEach(typemoq.It.isAny()))
+                .callback((callback) => {
+                    let result = iterableMock.next();
+                    while (!result.done) {
+                        callback(result.value[1]);
+                        result = iterableMock.next();
+                    }
+                })
+                .returns(() => mockTestItem1);
+            testItemCollectionMock.setup((x) => x.get('parentTest')).returns(() => mockParentItem);
+
+            testControllerMock.reset();
+            testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
+
             resultResolver = new ResultResolver.PythonResultResolver(
                 testControllerMock.object,
                 testProvider,
@@ -334,13 +364,16 @@ suite('Result Resolver tests', () => {
             );
             const subtestName = 'parentTest [subTest with spaces and [brackets]]';
             const mockSubtestItem = createMockTestItem(subtestName);
+
             // add a mock test item to the map of known VSCode ids to run ids
             resultResolver.runIdToVSid.set('mockTestItem2', 'mockTestItem2');
             // creates a mock test item with a space which will be used to split the runId
             resultResolver.runIdToVSid.set(subtestName, subtestName);
+            // Register parent test in testItemIndex so it can be found by getTestItem
+            resultResolver.runIdToVSid.set('parentTest', 'parentTest');
 
             // add this mock test to the map of known test items
-            resultResolver.runIdToTestItem.set('parentTest', mockTestItem2);
+            resultResolver.runIdToTestItem.set('parentTest', mockParentItem);
             resultResolver.runIdToTestItem.set(subtestName, mockSubtestItem);
 
             let generatedId: string | undefined;
@@ -563,15 +596,15 @@ suite('Result Resolver tests', () => {
 
 function createMockTestItem(id: string): TestItem {
     const range = new Range(0, 0, 0, 0);
+    const mockChildren = typemoq.Mock.ofType<TestItemCollection>();
+    mockChildren.setup((x) => x.add(typemoq.It.isAny())).returns(() => undefined);
+    mockChildren.setup((x) => x.forEach(typemoq.It.isAny())).returns(() => undefined);
+
     const mockTestItem = ({
         id,
         canResolveChildren: false,
         tags: [],
-        children: {
-            add: () => {
-                // empty
-            },
-        },
+        children: mockChildren.object,
         range,
         uri: Uri.file('/foo/bar'),
     } as unknown) as TestItem;
diff --git a/src/test/testing/testController/testCancellationRunAdapters.unit.test.ts b/src/test/testing/testController/testCancellationRunAdapters.unit.test.ts
index 81480d08b2b8..cdf0d00c5dc4 100644
--- a/src/test/testing/testController/testCancellationRunAdapters.unit.test.ts
+++ b/src/test/testing/testController/testCancellationRunAdapters.unit.test.ts
@@ -7,7 +7,7 @@ import * as sinon from 'sinon';
 import * as path from 'path';
 import { Observable } from 'rxjs';
 import { IPythonExecutionFactory, IPythonExecutionService, Output } from '../../../client/common/process/types';
-import { IConfigurationService, ITestOutputChannel } from '../../../client/common/types';
+import { IConfigurationService } from '../../../client/common/types';
 import { Deferred, createDeferred } from '../../../client/common/utils/async';
 import { EXTENSION_ROOT_DIR } from '../../../client/constants';
 import { ITestDebugLauncher } from '../../../client/testing/common/types';
@@ -16,6 +16,7 @@ import { UnittestTestExecutionAdapter } from '../../../client/testing/testContro
 import { MockChildProcess } from '../../mocks/mockChildProcess';
 import * as util from '../../../client/testing/testController/common/utils';
 import * as extapi from '../../../client/envExt/api.internal';
+import { noop } from '../../core';
 
 const adapters: Array<string> = ['pytest', 'unittest'];
 
@@ -36,6 +37,11 @@ suite('Execution Flow Run Adapters', () => {
     let useEnvExtensionStub: sinon.SinonStub;
 
     setup(() => {
+        const proc = typeMoq.Mock.ofType<MockChildProcess>();
+        proc.setup((p) => p.on).returns(() => noop as any);
+        proc.setup((p) => p.stdout).returns(() => null);
+        proc.setup((p) => p.stderr).returns(() => null);
+        mockProc = proc.object;
         useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension');
         useEnvExtensionStub.returns(false);
         // general vars
@@ -121,7 +127,7 @@ suite('Execution Flow Run Adapters', () => {
             });
 
             // define adapter and run tests
-            const testAdapter = createAdapter(adapter, configService, typeMoq.Mock.ofType<ITestOutputChannel>().object);
+            const testAdapter = createAdapter(adapter, configService);
             await testAdapter.runTests(
                 Uri.file(myTestPath),
                 [],
@@ -202,7 +208,7 @@ suite('Execution Flow Run Adapters', () => {
                 });
 
             // define adapter and run tests
-            const testAdapter = createAdapter(adapter, configService, typeMoq.Mock.ofType<ITestOutputChannel>().object);
+            const testAdapter = createAdapter(adapter, configService);
             await testAdapter.runTests(
                 Uri.file(myTestPath),
                 [],
@@ -221,9 +227,8 @@ suite('Execution Flow Run Adapters', () => {
 function createAdapter(
     adapterType: string,
     configService: IConfigurationService,
-    outputChannel: ITestOutputChannel,
 ): PytestTestExecutionAdapter | UnittestTestExecutionAdapter {
-    if (adapterType === 'pytest') return new PytestTestExecutionAdapter(configService, outputChannel);
-    if (adapterType === 'unittest') return new UnittestTestExecutionAdapter(configService, outputChannel);
+    if (adapterType === 'pytest') return new PytestTestExecutionAdapter(configService);
+    if (adapterType === 'unittest') return new UnittestTestExecutionAdapter(configService);
     throw Error('un-compatible adapter type');
 }
diff --git a/src/test/testing/testController/testMocks.ts b/src/test/testing/testController/testMocks.ts
new file mode 100644
index 000000000000..eb37d492f1d9
--- /dev/null
+++ b/src/test/testing/testController/testMocks.ts
@@ -0,0 +1,152 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+/**
+ * Centralized mock utilities for testing testController components.
+ * Re-use these helpers across multiple test files for consistency.
+ */
+
+import * as sinon from 'sinon';
+import * as typemoq from 'typemoq';
+import { TestItem, TestItemCollection, TestRun, Uri } from 'vscode';
+import { IPythonExecutionFactory } from '../../../client/common/process/types';
+import { ITestDebugLauncher } from '../../../client/testing/common/types';
+import { ProjectAdapter } from '../../../client/testing/testController/common/projectAdapter';
+import { ProjectExecutionDependencies } from '../../../client/testing/testController/common/projectTestExecution';
+import { TestProjectRegistry } from '../../../client/testing/testController/common/testProjectRegistry';
+import { ITestExecutionAdapter, ITestResultResolver } from '../../../client/testing/testController/common/types';
+
+/**
+ * Creates a mock TestItem with configurable properties.
+ * @param id - The unique ID of the test item
+ * @param uriPath - The file path for the test item's URI
+ * @param children - Optional array of child test items
+ */
+export function createMockTestItem(id: string, uriPath: string, children?: TestItem[]): TestItem {
+    const childMap = new Map<string, TestItem>();
+    children?.forEach((c) => childMap.set(c.id, c));
+
+    const mockChildren: TestItemCollection = {
+        size: childMap.size,
+        forEach: (callback: (item: TestItem, collection: TestItemCollection) => void) => {
+            childMap.forEach((item) => callback(item, mockChildren));
+        },
+        get: (itemId: string) => childMap.get(itemId),
+        add: () => {},
+        delete: () => {},
+        replace: () => {},
+        [Symbol.iterator]: function* () {
+            for (const [key, value] of childMap) {
+                yield [key, value] as [string, TestItem];
+            }
+        },
+    } as TestItemCollection;
+
+    return ({
+        id,
+        uri: Uri.file(uriPath),
+        children: mockChildren,
+        label: id,
+        canResolveChildren: false,
+        busy: false,
+        tags: [],
+        range: undefined,
+        error: undefined,
+        parent: undefined,
+    } as unknown) as TestItem;
+}
+
+/**
+ * Creates a mock TestItem without a URI.
+ * Useful for testing edge cases where test items have no associated file.
+ * @param id - The unique ID of the test item
+ */
+export function createMockTestItemWithoutUri(id: string): TestItem {
+    return ({
+        id,
+        uri: undefined,
+        children: ({ size: 0, forEach: () => {} } as unknown) as TestItemCollection,
+        label: id,
+    } as unknown) as TestItem;
+}
+
+export interface MockProjectAdapterConfig {
+    projectPath: string;
+    projectName: string;
+    pythonPath?: string;
+    testProvider?: 'pytest' | 'unittest';
+}
+
+export type MockProjectAdapter = ProjectAdapter & { executionAdapterStub: sinon.SinonStub };
+
+/**
+ * Creates a mock ProjectAdapter for testing project-based test execution.
+ * @param config - Configuration object with project details
+ * @returns A mock ProjectAdapter with an exposed executionAdapterStub for verification
+ */
+export function createMockProjectAdapter(config: MockProjectAdapterConfig): MockProjectAdapter {
+    const runTestsStub = sinon.stub().resolves();
+    const executionAdapter: ITestExecutionAdapter = ({
+        runTests: runTestsStub,
+    } as unknown) as ITestExecutionAdapter;
+
+    const resultResolverMock: ITestResultResolver = ({
+        vsIdToRunId: new Map<string, string>(),
+        runIdToVSid: new Map<string, string>(),
+        runIdToTestItem: new Map<string, TestItem>(),
+        detailedCoverageMap: new Map(),
+        resolveDiscovery: () => Promise.resolve(),
+        resolveExecution: () => {},
+    } as unknown) as ITestResultResolver;
+
+    const adapter = ({
+        projectUri: Uri.file(config.projectPath),
+        projectName: config.projectName,
+        workspaceUri: Uri.file(config.projectPath),
+        testProvider: config.testProvider ?? 'pytest',
+        pythonEnvironment: config.pythonPath
+            ? {
+                  execInfo: { run: { executable: config.pythonPath } },
+              }
+            : undefined,
+        pythonProject: {
+            name: config.projectName,
+            uri: Uri.file(config.projectPath),
+        },
+        executionAdapter,
+        discoveryAdapter: {} as any,
+        resultResolver: resultResolverMock,
+        isDiscovering: false,
+        isExecuting: false,
+        // Expose the stub for testing
+        executionAdapterStub: runTestsStub,
+    } as unknown) as MockProjectAdapter;
+
+    return adapter;
+}
+
+/**
+ * Creates mock dependencies for project test execution.
+ * @returns An object containing mocked ProjectExecutionDependencies
+ */
+export function createMockDependencies(): ProjectExecutionDependencies {
+    return {
+        projectRegistry: typemoq.Mock.ofType<TestProjectRegistry>().object,
+        pythonExecFactory: typemoq.Mock.ofType<IPythonExecutionFactory>().object,
+        debugLauncher: typemoq.Mock.ofType<ITestDebugLauncher>().object,
+    };
+}
+
+/**
+ * Creates a mock TestRun with common setup methods.
+ * @returns A TypeMoq mock of TestRun
+ */
+export function createMockTestRun(): typemoq.IMock<TestRun> {
+    const runMock = typemoq.Mock.ofType<TestRun>();
+    runMock.setup((r) => r.started(typemoq.It.isAny()));
+    runMock.setup((r) => r.passed(typemoq.It.isAny(), typemoq.It.isAny()));
+    runMock.setup((r) => r.failed(typemoq.It.isAny(), typemoq.It.isAny(), typemoq.It.isAny()));
+    runMock.setup((r) => r.skipped(typemoq.It.isAny()));
+    runMock.setup((r) => r.end());
+    return runMock;
+}
diff --git a/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts b/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts
index 0a2cfad866d5..031f30afba8a 100644
--- a/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts
+++ b/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts
@@ -9,7 +9,7 @@ import * as fs from 'fs';
 import { CancellationTokenSource, Uri } from 'vscode';
 import { Observable } from 'rxjs';
 import * as sinon from 'sinon';
-import { IConfigurationService, ITestOutputChannel } from '../../../../client/common/types';
+import { IConfigurationService } from '../../../../client/common/types';
 import { EXTENSION_ROOT_DIR } from '../../../../client/constants';
 import { UnittestTestDiscoveryAdapter } from '../../../../client/testing/testController/unittest/testDiscoveryAdapter';
 import { Deferred, createDeferred } from '../../../../client/common/utils/async';
@@ -22,10 +22,10 @@ import {
     SpawnOptions,
 } from '../../../../client/common/process/types';
 import * as extapi from '../../../../client/envExt/api.internal';
+import { ProjectAdapter } from '../../../../client/testing/testController/common/projectAdapter';
 
 suite('Unittest test discovery adapter', () => {
     let configService: IConfigurationService;
-    let outputChannel: typeMoq.IMock<ITestOutputChannel>;
     let mockProc: MockChildProcess;
     let execService: typeMoq.IMock<IPythonExecutionService>;
     let execFactory = typeMoq.Mock.ofType<IPythonExecutionFactory>();
@@ -47,7 +47,6 @@ suite('Unittest test discovery adapter', () => {
                 testing: { unittestArgs: ['-v', '-s', '.', '-p', 'test*'] },
             }),
         } as unknown) as IConfigurationService;
-        outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
 
         // set up exec service with child process
         mockProc = new MockChildProcess('', ['']);
@@ -94,7 +93,7 @@ suite('Unittest test discovery adapter', () => {
     });
 
     test('DiscoverTests should send the discovery command to the test server with the correct args', async () => {
-        const adapter = new UnittestTestDiscoveryAdapter(configService, outputChannel.object);
+        const adapter = new UnittestTestDiscoveryAdapter(configService);
         adapter.discoverTests(uri, execFactory.object);
         const script = path.join(EXTENSION_ROOT_DIR, 'python_files', 'unittestadapter', 'discovery.py');
         const argsExpected = [script, '--udiscovery', '-v', '-s', '.', '-p', 'test*'];
@@ -137,7 +136,7 @@ suite('Unittest test discovery adapter', () => {
                 testing: { unittestArgs: ['-v', '-s', '.', '-p', 'test*'], cwd: expectedNewPath.toString() },
             }),
         } as unknown) as IConfigurationService;
-        const adapter = new UnittestTestDiscoveryAdapter(configService, outputChannel.object);
+        const adapter = new UnittestTestDiscoveryAdapter(configService);
         adapter.discoverTests(uri, execFactory.object);
         const script = path.join(EXTENSION_ROOT_DIR, 'python_files', 'unittestadapter', 'discovery.py');
         const argsExpected = [script, '--udiscovery', '-v', '-s', '.', '-p', 'test*'];
@@ -189,7 +188,7 @@ suite('Unittest test discovery adapter', () => {
         );
         sinon.stub(fs.promises, 'realpath').callsFake(async (pathEntered) => pathEntered.toString());
 
-        const adapter = new UnittestTestDiscoveryAdapter(configService, outputChannel.object);
+        const adapter = new UnittestTestDiscoveryAdapter(configService);
         const discoveryPromise = adapter.discoverTests(uri, execFactory.object, cancellationTokenSource.token);
 
         // Trigger cancellation before exec observable call finishes
@@ -239,11 +238,105 @@ suite('Unittest test discovery adapter', () => {
         );
         sinon.stub(fs.promises, 'realpath').callsFake(async (pathEntered) => pathEntered.toString());
 
-        const adapter = new UnittestTestDiscoveryAdapter(configService, outputChannel.object);
+        const adapter = new UnittestTestDiscoveryAdapter(configService);
         const discoveryPromise = adapter.discoverTests(uri, execFactory.object, cancellationTokenSource.token);
 
         // add in await and trigger
         await discoveryPromise;
         assert.ok(true, 'Test resolves correctly when triggering a cancellation token in exec observable.');
     });
+
+    test('DiscoverTests should set PROJECT_ROOT_PATH when project is provided', async () => {
+        const projectPath = path.join('/', 'workspace', 'myproject');
+        const mockProject = ({
+            projectId: 'file:///workspace/myproject',
+            projectUri: Uri.file(projectPath),
+            projectName: 'myproject',
+            workspaceUri: Uri.file('/workspace'),
+        } as unknown) as ProjectAdapter;
+
+        const adapter = new UnittestTestDiscoveryAdapter(configService);
+        adapter.discoverTests(uri, execFactory.object, undefined, undefined, mockProject);
+        const script = path.join(EXTENSION_ROOT_DIR, 'python_files', 'unittestadapter', 'discovery.py');
+        const argsExpected = [script, '--udiscovery', '-v', '-s', '.', '-p', 'test*'];
+
+        // must await until the execObservable is called in order to verify it
+        await deferred.promise;
+
+        execService.verify(
+            (x) =>
+                x.execObservable(
+                    typeMoq.It.is<Array<string>>((argsActual) => {
+                        try {
+                            assert.equal(argsActual.length, argsExpected.length);
+                            assert.deepEqual(argsActual, argsExpected);
+                            return true;
+                        } catch (e) {
+                            console.error(e);
+                            throw e;
+                        }
+                    }),
+                    typeMoq.It.is<SpawnOptions>((options) => {
+                        try {
+                            // Verify PROJECT_ROOT_PATH is set when project is provided
+                            assert.strictEqual(
+                                options.env?.PROJECT_ROOT_PATH,
+                                projectPath,
+                                'PROJECT_ROOT_PATH should be set to project URI path',
+                            );
+                            assert.equal(options.cwd, expectedPath);
+                            assert.equal(options.throwOnStdErr, true);
+                            return true;
+                        } catch (e) {
+                            console.error(e);
+                            throw e;
+                        }
+                    }),
+                ),
+            typeMoq.Times.once(),
+        );
+    });
+
+    test('DiscoverTests should NOT set PROJECT_ROOT_PATH when no project is provided', async () => {
+        const adapter = new UnittestTestDiscoveryAdapter(configService);
+        adapter.discoverTests(uri, execFactory.object);
+        const script = path.join(EXTENSION_ROOT_DIR, 'python_files', 'unittestadapter', 'discovery.py');
+        const argsExpected = [script, '--udiscovery', '-v', '-s', '.', '-p', 'test*'];
+
+        // must await until the execObservable is called in order to verify it
+        await deferred.promise;
+
+        execService.verify(
+            (x) =>
+                x.execObservable(
+                    typeMoq.It.is<Array<string>>((argsActual) => {
+                        try {
+                            assert.equal(argsActual.length, argsExpected.length);
+                            assert.deepEqual(argsActual, argsExpected);
+                            return true;
+                        } catch (e) {
+                            console.error(e);
+                            throw e;
+                        }
+                    }),
+                    typeMoq.It.is<SpawnOptions>((options) => {
+                        try {
+                            // Verify PROJECT_ROOT_PATH is NOT set when no project is provided
+                            assert.strictEqual(
+                                options.env?.PROJECT_ROOT_PATH,
+                                undefined,
+                                'PROJECT_ROOT_PATH should NOT be set when no project is provided',
+                            );
+                            assert.equal(options.cwd, expectedPath);
+                            assert.equal(options.throwOnStdErr, true);
+                            return true;
+                        } catch (e) {
+                            console.error(e);
+                            throw e;
+                        }
+                    }),
+                ),
+            typeMoq.Times.once(),
+        );
+    });
 });
diff --git a/src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts b/src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts
index 688d6d398101..8a86e9228567 100644
--- a/src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts
+++ b/src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts
@@ -7,7 +7,7 @@ import * as typeMoq from 'typemoq';
 import * as sinon from 'sinon';
 import * as path from 'path';
 import { Observable } from 'rxjs/Observable';
-import { IConfigurationService, ITestOutputChannel } from '../../../../client/common/types';
+import { IConfigurationService } from '../../../../client/common/types';
 import {
     IPythonExecutionFactory,
     IPythonExecutionService,
@@ -22,6 +22,8 @@ import { MockChildProcess } from '../../../mocks/mockChildProcess';
 import { traceInfo } from '../../../../client/logging';
 import { UnittestTestExecutionAdapter } from '../../../../client/testing/testController/unittest/testExecutionAdapter';
 import * as extapi from '../../../../client/envExt/api.internal';
+import { ProjectAdapter } from '../../../../client/testing/testController/common/projectAdapter';
+import { createMockProjectAdapter } from '../testMocks';
 
 suite('Unittest test execution adapter', () => {
     let configService: IConfigurationService;
@@ -116,8 +118,7 @@ suite('Unittest test execution adapter', () => {
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new UnittestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new UnittestTestExecutionAdapter(configService);
         const testIds = ['test1id', 'test2id'];
 
         adapter.runTests(uri, testIds, TestRunProfileKind.Run, testRun.object, execFactory.object);
@@ -147,8 +148,7 @@ suite('Unittest test execution adapter', () => {
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new UnittestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new UnittestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Run, testRun.object, execFactory.object);
 
         await deferred2.promise;
@@ -205,8 +205,7 @@ suite('Unittest test execution adapter', () => {
             isTestExecution: () => false,
         } as unknown) as IConfigurationService;
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new UnittestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new UnittestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Run, testRun.object, execFactory.object);
 
         await deferred2.promise;
@@ -261,8 +260,7 @@ suite('Unittest test execution adapter', () => {
                     } as any),
             );
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new UnittestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new UnittestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Debug, testRun.object, execFactory.object, debugLauncher.object);
         await deferred3.promise;
         debugLauncher.verify(
@@ -302,8 +300,7 @@ suite('Unittest test execution adapter', () => {
         const testRun = typeMoq.Mock.ofType<TestRun>();
         testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
         const uri = Uri.file(myTestPath);
-        const outputChannel = typeMoq.Mock.ofType<ITestOutputChannel>();
-        adapter = new UnittestTestExecutionAdapter(configService, outputChannel.object);
+        adapter = new UnittestTestExecutionAdapter(configService);
         adapter.runTests(uri, [], TestRunProfileKind.Coverage, testRun.object, execFactory.object);
 
         await deferred2.promise;
@@ -326,4 +323,259 @@ suite('Unittest test execution adapter', () => {
             typeMoq.Times.once(),
         );
     });
+
+    test('RunTests should set PROJECT_ROOT_PATH when project is provided', async () => {
+        const deferred2 = createDeferred();
+        const deferred3 = createDeferred();
+        execFactory = typeMoq.Mock.ofType<IPythonExecutionFactory>();
+        execFactory
+            .setup((x) => x.createActivatedEnvironment(typeMoq.It.isAny()))
+            .returns(() => {
+                deferred2.resolve();
+                return Promise.resolve(execService.object);
+            });
+        utilsWriteTestIdsFileStub.callsFake(() => {
+            deferred3.resolve();
+            return Promise.resolve('testIdPipe-mockName');
+        });
+
+        const projectPath = path.join('/', 'workspace', 'myproject');
+        const mockProject = ({
+            projectId: 'file:///workspace/myproject',
+            projectUri: Uri.file(projectPath),
+            projectName: 'myproject',
+            workspaceUri: Uri.file('/workspace'),
+        } as unknown) as ProjectAdapter;
+
+        const testRun = typeMoq.Mock.ofType<TestRun>();
+        testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
+        const uri = Uri.file(myTestPath);
+        adapter = new UnittestTestExecutionAdapter(configService);
+        adapter.runTests(
+            uri,
+            [],
+            TestRunProfileKind.Run,
+            testRun.object,
+            execFactory.object,
+            undefined, // debugLauncher
+            undefined, // interpreter
+            mockProject,
+        );
+
+        await deferred2.promise;
+        await deferred3.promise;
+        await deferred4.promise;
+        mockProc.trigger('close');
+
+        const pathToPythonFiles = path.join(EXTENSION_ROOT_DIR, 'python_files');
+        const pathToExecutionScript = path.join(pathToPythonFiles, 'unittestadapter', 'execution.py');
+        const expectedArgs = [pathToExecutionScript, '--udiscovery', '.'];
+
+        execService.verify(
+            (x) =>
+                x.execObservable(
+                    expectedArgs,
+                    typeMoq.It.is<SpawnOptions>((options) => {
+                        // Verify PROJECT_ROOT_PATH is set when project is provided
+                        assert.strictEqual(
+                            options.env?.PROJECT_ROOT_PATH,
+                            projectPath,
+                            'PROJECT_ROOT_PATH should be set to project URI path',
+                        );
+                        return true;
+                    }),
+                ),
+            typeMoq.Times.once(),
+        );
+    });
+
+    test('RunTests should NOT set PROJECT_ROOT_PATH when no project is provided', async () => {
+        const deferred2 = createDeferred();
+        const deferred3 = createDeferred();
+        execFactory = typeMoq.Mock.ofType<IPythonExecutionFactory>();
+        execFactory
+            .setup((x) => x.createActivatedEnvironment(typeMoq.It.isAny()))
+            .returns(() => {
+                deferred2.resolve();
+                return Promise.resolve(execService.object);
+            });
+        utilsWriteTestIdsFileStub.callsFake(() => {
+            deferred3.resolve();
+            return Promise.resolve('testIdPipe-mockName');
+        });
+        const testRun = typeMoq.Mock.ofType<TestRun>();
+        testRun.setup((t) => t.token).returns(() => ({ onCancellationRequested: () => undefined } as any));
+        const uri = Uri.file(myTestPath);
+        adapter = new UnittestTestExecutionAdapter(configService);
+        adapter.runTests(uri, [], TestRunProfileKind.Run, testRun.object, execFactory.object);
+
+        await deferred2.promise;
+        await deferred3.promise;
+        await deferred4.promise;
+        mockProc.trigger('close');
+
+        const pathToPythonFiles = path.join(EXTENSION_ROOT_DIR, 'python_files');
+        const pathToExecutionScript = path.join(pathToPythonFiles, 'unittestadapter', 'execution.py');
+        const expectedArgs = [pathToExecutionScript, '--udiscovery', '.'];
+
+        execService.verify(
+            (x) =>
+                x.execObservable(
+                    expectedArgs,
+                    typeMoq.It.is<SpawnOptions>((options) => {
+                        // Verify PROJECT_ROOT_PATH is NOT set when no project is provided
+                        assert.strictEqual(
+                            options.env?.PROJECT_ROOT_PATH,
+                            undefined,
+                            'PROJECT_ROOT_PATH should NOT be set when no project is provided',
+                        );
+                        return true;
+                    }),
+                ),
+            typeMoq.Times.once(),
+        );
+    });
+
+    test('Debug mode with project should pass project.pythonProject to debug launcher', async () => {
+        const deferred3 = createDeferred();
+        utilsWriteTestIdsFileStub.callsFake(() => Promise.resolve('testIdPipe-mockName'));
+
+        debugLauncher
+            .setup((dl) => dl.launchDebugger(typeMoq.It.isAny(), typeMoq.It.isAny(), typeMoq.It.isAny()))
+            .returns(async (_opts, callback) => {
+                traceInfo('stubs launch debugger');
+                if (typeof callback === 'function') {
+                    deferred3.resolve();
+                    callback();
+                }
+            });
+
+        const testRun = typeMoq.Mock.ofType<TestRun>();
+        testRun
+            .setup((t) => t.token)
+            .returns(
+                () =>
+                    ({
+                        onCancellationRequested: () => undefined,
+                    } as any),
+            );
+
+        const projectPath = path.join('/', 'workspace', 'myproject');
+        const mockProject = createMockProjectAdapter({
+            projectPath,
+            projectName: 'myproject (Python 3.11)',
+            pythonPath: '/custom/python/path',
+            testProvider: 'unittest',
+        });
+
+        const uri = Uri.file(myTestPath);
+        adapter = new UnittestTestExecutionAdapter(configService);
+        adapter.runTests(
+            uri,
+            [],
+            TestRunProfileKind.Debug,
+            testRun.object,
+            execFactory.object,
+            debugLauncher.object,
+            undefined,
+            mockProject,
+        );
+
+        await deferred3.promise;
+
+        debugLauncher.verify(
+            (x) =>
+                x.launchDebugger(
+                    typeMoq.It.is<LaunchOptions>((launchOptions) => {
+                        // Project should be passed for project-based debugging
+                        assert.ok(launchOptions.project, 'project should be defined');
+                        assert.equal(launchOptions.project?.name, 'myproject (Python 3.11)');
+                        assert.equal(launchOptions.project?.uri.fsPath, projectPath);
+                        return true;
+                    }),
+                    typeMoq.It.isAny(),
+                    typeMoq.It.isAny(),
+                ),
+            typeMoq.Times.once(),
+        );
+    });
+
+    test('useEnvExtension mode with project should use project pythonEnvironment', async () => {
+        // Enable the useEnvExtension path
+        useEnvExtensionStub.returns(true);
+
+        utilsWriteTestIdsFileStub.callsFake(() => Promise.resolve('testIdPipe-mockName'));
+
+        // Store the deferredTillServerClose so we can resolve it
+        let serverCloseDeferred: Deferred<void> | undefined;
+        utilsStartRunResultNamedPipeStub.callsFake((_callback: unknown, deferred: Deferred<void>, _token: unknown) => {
+            serverCloseDeferred = deferred;
+            return Promise.resolve('runResultPipe-mockName');
+        });
+
+        const projectPath = path.join('/', 'workspace', 'myproject');
+        const mockProject = createMockProjectAdapter({
+            projectPath,
+            projectName: 'myproject (Python 3.11)',
+            pythonPath: '/custom/python/path',
+            testProvider: 'unittest',
+        });
+
+        // Stub runInBackground to capture which environment was used
+        const runInBackgroundStub = sinon.stub(extapi, 'runInBackground');
+        const exitCallbacks: ((code: number, signal: string | null) => void)[] = [];
+        // Promise that resolves when the production code registers its onExit handler
+        const onExitRegistered = createDeferred<void>();
+        const mockProc2 = {
+            stdout: { on: sinon.stub() },
+            stderr: { on: sinon.stub() },
+            onExit: (cb: (code: number, signal: string | null) => void) => {
+                exitCallbacks.push(cb);
+                onExitRegistered.resolve();
+            },
+            kill: sinon.stub(),
+        };
+        runInBackgroundStub.callsFake(() => Promise.resolve(mockProc2 as any));
+
+        const testRun = typeMoq.Mock.ofType<TestRun>();
+        testRun
+            .setup((t) => t.token)
+            .returns(
+                () =>
+                    ({
+                        onCancellationRequested: () => undefined,
+                    } as any),
+            );
+
+        const uri = Uri.file(myTestPath);
+        adapter = new UnittestTestExecutionAdapter(configService);
+        const runPromise = adapter.runTests(
+            uri,
+            [],
+            TestRunProfileKind.Run,
+            testRun.object,
+            execFactory.object,
+            debugLauncher.object,
+            undefined,
+            mockProject,
+        );
+
+        // Wait for production code to register its onExit handler
+        await onExitRegistered.promise;
+
+        // Simulate process exit to complete the test
+        exitCallbacks.forEach((cb) => cb(0, null));
+
+        // Resolve the server close deferred to allow the runTests to complete
+        serverCloseDeferred?.resolve();
+
+        await runPromise;
+
+        // Verify runInBackground was called with the project's Python environment
+        sinon.assert.calledOnce(runInBackgroundStub);
+        const envArg = runInBackgroundStub.firstCall.args[0];
+        // The environment should be the project's pythonEnvironment
+        assert.ok(envArg, 'runInBackground should be called with an environment');
+        assert.equal(envArg.execInfo?.run?.executable, '/custom/python/path');
+    });
 });
diff --git a/src/test/testing/testController/utils.unit.test.ts b/src/test/testing/testController/utils.unit.test.ts
index 4d2af9da3d5a..3cba6fb697a5 100644
--- a/src/test/testing/testController/utils.unit.test.ts
+++ b/src/test/testing/testController/utils.unit.test.ts
@@ -2,8 +2,15 @@ import * as assert from 'assert';
 import * as sinon from 'sinon';
 import * as fs from 'fs';
 import * as path from 'path';
-import { writeTestIdsFile } from '../../../client/testing/testController/common/utils';
+import { CancellationToken, TestController, TestItem, Uri, Range, Position } from 'vscode';
+import { writeTestIdsFile, populateTestTree } from '../../../client/testing/testController/common/utils';
 import { EXTENSION_ROOT_DIR } from '../../../client/constants';
+import {
+    DiscoveredTestNode,
+    DiscoveredTestItem,
+    ITestResultResolver,
+} from '../../../client/testing/testController/common/types';
+import { RunTestTag, DebugTestTag } from '../../../client/testing/testController/common/testItemUtilities';
 
 suite('writeTestIdsFile tests', () => {
     let sandbox: sinon.SinonSandbox;
@@ -87,3 +94,661 @@ suite('getTempDir tests', () => {
         assert.ok(result.startsWith('/xdg/runtime/dir'));
     });
 });
+
+suite('populateTestTree tests', () => {
+    let sandbox: sinon.SinonSandbox;
+    let testController: TestController;
+    let resultResolver: ITestResultResolver;
+    let cancelationToken: CancellationToken;
+    let createTestItemStub: sinon.SinonStub;
+    let itemsAddStub: sinon.SinonStub;
+    let itemsGetStub: sinon.SinonStub;
+
+    setup(() => {
+        sandbox = sinon.createSandbox();
+
+        // Create stubs for TestController methods
+        createTestItemStub = sandbox.stub();
+        itemsAddStub = sandbox.stub();
+        itemsGetStub = sandbox.stub();
+
+        // Create mock TestController
+        testController = {
+            createTestItem: createTestItemStub,
+            items: {
+                add: itemsAddStub,
+                get: itemsGetStub,
+                delete: sandbox.stub(),
+                replace: sandbox.stub(),
+                forEach: sandbox.stub(),
+                size: 0,
+                [Symbol.iterator]: sandbox.stub(),
+            },
+        } as any;
+
+        // Create mock result resolver
+        resultResolver = {
+            runIdToTestItem: new Map(),
+            runIdToVSid: new Map(),
+            vsIdToRunId: new Map(),
+            detailedCoverageMap: new Map(),
+            resolveDiscovery: sandbox.stub(),
+            resolveExecution: sandbox.stub(),
+            _resolveDiscovery: sandbox.stub(),
+            _resolveExecution: sandbox.stub(),
+            _resolveCoverage: sandbox.stub(),
+        };
+
+        // Mock cancellation token
+        cancelationToken = {
+            isCancellationRequested: false,
+            onCancellationRequested: sandbox.stub(),
+        } as any;
+    });
+
+    teardown(() => {
+        sandbox.restore();
+    });
+
+    test('should create a root node if testRoot is undefined', () => {
+        // Arrange
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [],
+        };
+
+        const mockRootItem: TestItem = {
+            id: '/test/path/root',
+            label: 'RootTest',
+            uri: Uri.file('/test/path/root'),
+            canResolveChildren: true,
+            tags: [RunTestTag, DebugTestTag],
+            children: {
+                add: sandbox.stub(),
+                get: sandbox.stub(),
+                delete: sandbox.stub(),
+                replace: sandbox.stub(),
+                forEach: sandbox.stub(),
+                size: 0,
+                [Symbol.iterator]: sandbox.stub(),
+            },
+        } as any;
+
+        createTestItemStub.returns(mockRootItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, undefined, resultResolver, cancelationToken);
+
+        // Assert
+        assert.ok(createTestItemStub.calledOnce);
+        // Check the args manually - function uses testTreeData.path as id
+        const call = createTestItemStub.firstCall;
+        assert.strictEqual(call.args[0], '/test/path/root');
+        assert.strictEqual(call.args[1], 'RootTest');
+        // Don't check Uri.file since it's complex to compare
+        assert.ok(itemsAddStub.calledOnceWith(mockRootItem));
+        assert.strictEqual(mockRootItem.canResolveChildren, true);
+        assert.deepStrictEqual(mockRootItem.tags, [RunTestTag, DebugTestTag]);
+    });
+
+    test('should recursively add children as TestItems', () => {
+        // Arrange
+        // Tree structure:
+        // RootWorkspaceFolder (folder)
+        // └── test_example (test)
+        const testItem: DiscoveredTestItem = {
+            path: '/test/path/test.py',
+            name: 'test_example',
+            type_: 'test',
+            id_: 'test-id',
+            lineno: 10,
+            runID: 'run-id-123',
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootWorkspaceFolder',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem],
+        };
+
+        const childrenAddStub = sandbox.stub();
+        const mockRootItem: TestItem = {
+            id: 'root-id',
+            children: {
+                add: childrenAddStub,
+            },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            id: 'test-id',
+            label: 'test_example',
+            uri: Uri.file('/test/path/test.py'),
+            canResolveChildren: false,
+            tags: [],
+            range: undefined,
+        } as any;
+
+        createTestItemStub.returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        assert.ok(createTestItemStub.calledOnceWith('test-id', 'test_example', sinon.match.any));
+        assert.ok(childrenAddStub.calledOnceWith(mockTestItem));
+        assert.strictEqual(mockTestItem.canResolveChildren, false);
+        assert.deepStrictEqual(mockTestItem.tags, [RunTestTag, DebugTestTag]);
+    });
+
+    test('should create TestItem with correct range when lineno is provided', () => {
+        // Arrange
+        const testItem: DiscoveredTestItem = {
+            path: '/test/path/test.py',
+            name: 'test_example',
+            type_: 'test',
+            id_: 'test-id',
+            lineno: 5,
+            runID: 'run-id-123',
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem],
+        };
+
+        const mockRootItem: TestItem = {
+            children: { add: sandbox.stub() },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            tags: [],
+            range: undefined,
+        } as any;
+
+        createTestItemStub.returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        const expectedRange = new Range(new Position(4, 0), new Position(5, 0));
+        assert.deepStrictEqual(mockTestItem.range, expectedRange);
+    });
+
+    test('should handle lineno = 0 correctly', () => {
+        // Arrange
+        const testItem: DiscoveredTestItem = {
+            path: '/test/path/test.py',
+            name: 'test_example',
+            type_: 'test',
+            id_: 'test-id',
+            lineno: '0',
+            runID: 'run-id-123',
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem],
+        };
+
+        const mockRootItem: TestItem = {
+            children: { add: sandbox.stub() },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            tags: [],
+            range: undefined,
+        } as any;
+
+        createTestItemStub.returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert- if lineno is '0', range should be defined but at the top
+        const expectedRange = new Range(new Position(0, 0), new Position(0, 0));
+
+        assert.deepStrictEqual(mockTestItem.range, expectedRange);
+    });
+
+    test('should update resultResolver mappings correctly for test items', () => {
+        // Arrange
+        const testItem: DiscoveredTestItem = {
+            path: '/test/path/test.py',
+            name: 'test_example',
+            type_: 'test',
+            id_: 'test-id',
+            lineno: 10,
+            runID: 'run-id-123',
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem],
+        };
+
+        const mockRootItem: TestItem = {
+            children: { add: sandbox.stub() },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            id: 'test-id',
+            tags: [],
+        } as any;
+
+        createTestItemStub.returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        assert.strictEqual(resultResolver.runIdToTestItem.get('run-id-123'), mockTestItem);
+        assert.strictEqual(resultResolver.runIdToVSid.get('run-id-123'), 'test-id');
+        assert.strictEqual(resultResolver.vsIdToRunId.get('test-id'), 'run-id-123');
+    });
+
+    test('should create nodes for non-leaf items and recurse', () => {
+        // Arrange
+        // Tree structure:
+        // RootTest (folder)
+        // └── NestedFolder (folder)
+        //     └── nested_test (test)
+        const nestedTestItem: DiscoveredTestItem = {
+            path: '/test/path/nested_test.py',
+            name: 'nested_test',
+            type_: 'test',
+            id_: 'nested-test-id',
+            lineno: 5,
+            runID: 'nested-run-id',
+        };
+
+        const nestedNode: DiscoveredTestNode = {
+            path: '/test/path/nested',
+            name: 'NestedFolder',
+            type_: 'folder',
+            id_: 'nested-id',
+            children: [nestedTestItem],
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [nestedNode],
+        };
+
+        const rootChildrenAddStub = sandbox.stub();
+        const rootChildrenGetStub = sandbox.stub().returns(undefined);
+        const mockRootItem: TestItem = {
+            children: { add: rootChildrenAddStub, get: rootChildrenGetStub },
+        } as any;
+
+        const nestedChildrenAddStub = sandbox.stub();
+        const nestedChildrenGetStub = sandbox.stub().returns(undefined);
+        const mockNestedNode: TestItem = {
+            id: 'nested-id',
+            canResolveChildren: true,
+            tags: [],
+            children: { add: nestedChildrenAddStub, get: nestedChildrenGetStub },
+        } as any;
+
+        const mockNestedTestItem: TestItem = {
+            id: 'nested-test-id',
+            tags: [],
+        } as any;
+
+        createTestItemStub.onFirstCall().returns(mockNestedNode);
+        createTestItemStub.onSecondCall().returns(mockNestedTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        // Should create nested node - uses child.id_ for non-leaf nodes
+        assert.ok(createTestItemStub.calledWith('nested-id', 'NestedFolder', sinon.match.any));
+        assert.ok(rootChildrenAddStub.calledWith(mockNestedNode));
+        assert.strictEqual(mockNestedNode.canResolveChildren, true);
+        assert.deepStrictEqual(mockNestedNode.tags, [RunTestTag, DebugTestTag]);
+
+        // Should create nested test item - uses child.id_ for test items too
+        assert.ok(createTestItemStub.calledWith('nested-test-id', 'nested_test', sinon.match.any));
+        assert.ok(nestedChildrenAddStub.calledWith(mockNestedTestItem));
+    });
+
+    test('should reuse existing nodes when they already exist', () => {
+        // Arrange
+        // Tree structure:
+        // RootTest (folder)
+        // └── ExistingFolder (folder, already exists)
+        //     └── test_example (test)
+        const testItem: DiscoveredTestItem = {
+            path: '/test/path/test.py',
+            name: 'test_example',
+            type_: 'test',
+            id_: 'test-id',
+            lineno: 10,
+            runID: 'run-id-123',
+        };
+
+        const nestedNode: DiscoveredTestNode = {
+            path: '/test/path/existing',
+            name: 'ExistingFolder',
+            type_: 'folder',
+            id_: 'existing-id',
+            children: [testItem],
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [nestedNode],
+        };
+
+        const rootChildrenAddStub = sandbox.stub();
+        const existingChildrenAddStub = sandbox.stub();
+        const existingChildrenGetStub = sandbox.stub().returns(undefined);
+        const existingNode: TestItem = {
+            id: 'existing-id',
+            children: { add: existingChildrenAddStub, get: existingChildrenGetStub },
+        } as any;
+        const rootChildrenGetStub = sandbox.stub().withArgs('existing-id').returns(existingNode);
+        const mockRootItem: TestItem = {
+            children: { add: rootChildrenAddStub, get: rootChildrenGetStub },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            tags: [],
+        } as any;
+
+        // Mock existing node in testController.items
+        itemsGetStub.withArgs('/test/path/existing').returns(existingNode);
+        createTestItemStub.returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        // Should not create a new node, should reuse existing one
+        assert.ok(createTestItemStub.calledOnceWith('test-id', 'test_example', sinon.match.any));
+        // Should not create a new node for the existing folder
+        assert.ok(createTestItemStub.neverCalledWith('existing-id', 'ExistingFolder', sinon.match.any));
+        assert.ok(existingChildrenAddStub.calledWith(mockTestItem));
+        // Should not add existing node to root children again
+        assert.ok(rootChildrenAddStub.notCalled);
+    });
+
+    test('should respect cancellation token and stop processing', () => {
+        // Arrange
+        const testItem1: DiscoveredTestItem = {
+            path: '/test/path/test1.py',
+            name: 'test1',
+            type_: 'test',
+            id_: 'test1-id',
+            lineno: 10,
+            runID: 'run-id-1',
+        };
+
+        const testItem2: DiscoveredTestItem = {
+            path: '/test/path/test2.py',
+            name: 'test2',
+            type_: 'test',
+            id_: 'test2-id',
+            lineno: 20,
+            runID: 'run-id-2',
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem1, testItem2],
+        };
+
+        const rootChildrenAddStub = sandbox.stub();
+        const mockRootItem: TestItem = {
+            children: { add: rootChildrenAddStub },
+        } as any;
+
+        // Set cancellation token to be cancelled
+        const cancelledToken = {
+            isCancellationRequested: true,
+            onCancellationRequested: sandbox.stub(),
+        } as any;
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelledToken);
+
+        // Assert - no test items should be created when cancelled
+        assert.ok(createTestItemStub.notCalled);
+        assert.ok(rootChildrenAddStub.notCalled);
+        assert.strictEqual(resultResolver.runIdToTestItem.size, 0);
+    });
+
+    test('should handle empty children array gracefully', () => {
+        // Arrange
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [],
+        };
+
+        const rootChildrenAddStub = sandbox.stub();
+        const mockRootItem: TestItem = {
+            children: { add: rootChildrenAddStub },
+        } as any;
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert - should complete without errors
+        assert.ok(createTestItemStub.notCalled);
+        assert.ok(rootChildrenAddStub.notCalled);
+    });
+
+    test('should add correct tags to all created items', () => {
+        // Arrange
+        // Tree structure:
+        // RootTest (folder)
+        // └── NestedFolder (folder)
+        //     └── test_example (test)
+        const testItem: DiscoveredTestItem = {
+            path: '/test/path/test.py',
+            name: 'test_example',
+            type_: 'test',
+            id_: 'test-id',
+            lineno: 10,
+            runID: 'run-id-123',
+        };
+
+        const nestedNode: DiscoveredTestNode = {
+            path: '/test/path/nested',
+            name: 'NestedFolder',
+            type_: 'folder',
+            id_: 'nested-id',
+            children: [testItem],
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [nestedNode],
+        };
+
+        const mockRootItem: TestItem = {
+            id: 'root-id',
+            tags: [],
+            canResolveChildren: true,
+            children: { add: sandbox.stub(), get: sandbox.stub().returns(undefined) },
+        } as any;
+
+        const mockNestedNode: TestItem = {
+            id: 'nested-id',
+            tags: [],
+            canResolveChildren: true,
+            children: { add: sandbox.stub(), get: sandbox.stub().returns(undefined) },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            id: 'test-id',
+            tags: [],
+            canResolveChildren: false,
+        } as any;
+
+        createTestItemStub.onCall(0).returns(mockRootItem);
+        createTestItemStub.onCall(1).returns(mockNestedNode);
+        createTestItemStub.onCall(2).returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, undefined, resultResolver, cancelationToken);
+
+        // Assert - All items should have RunTestTag and DebugTestTag
+        assert.deepStrictEqual(mockRootItem.tags, [RunTestTag, DebugTestTag]);
+        assert.deepStrictEqual(mockNestedNode.tags, [RunTestTag, DebugTestTag]);
+        assert.deepStrictEqual(mockTestItem.tags, [RunTestTag, DebugTestTag]);
+    });
+    test('should handle a test node with no lineno property', () => {
+        // Arrange
+        // Tree structure:
+        // RootTest (folder)
+        // └── test_without_lineno (test, no lineno)
+        const testItem = {
+            path: '/test/path/test.py',
+            name: 'test_without_lineno',
+            type_: 'test',
+            id_: 'test-no-lineno-id',
+            runID: 'run-id-no-lineno',
+        } as DiscoveredTestItem;
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem],
+        };
+
+        const childrenAddStub = sandbox.stub();
+        const mockRootItem: TestItem = {
+            id: 'root-id',
+            children: {
+                add: childrenAddStub,
+            },
+        } as any;
+
+        const mockTestItem: TestItem = {
+            id: 'test-no-lineno-id',
+            label: 'test_without_lineno',
+            uri: Uri.file('/test/path/test.py'),
+            canResolveChildren: false,
+            tags: [],
+            range: undefined,
+        } as any;
+
+        createTestItemStub.returns(mockTestItem);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        assert.ok(createTestItemStub.calledOnceWith('test-no-lineno-id', 'test_without_lineno', sinon.match.any));
+        assert.ok(childrenAddStub.calledOnceWith(mockTestItem));
+        // range is undefined since lineno is not provided
+        assert.strictEqual(mockTestItem.range, undefined);
+        assert.deepStrictEqual(mockTestItem.tags, [RunTestTag, DebugTestTag]);
+    });
+
+    test('should handle a node with multiple children', () => {
+        // Arrange
+        // Tree structure:
+        // RootTest (folder)
+        // ├── test_one (test)
+        // └── test_two (test)
+        const testItem1: DiscoveredTestItem = {
+            path: '/test/path/test1.py',
+            name: 'test_one',
+            type_: 'test',
+            id_: 'test-one-id',
+            lineno: 3,
+            runID: 'run-id-one',
+        };
+        const testItem2: DiscoveredTestItem = {
+            path: '/test/path/test2.py',
+            name: 'test_two',
+            type_: 'test',
+            id_: 'test-two-id',
+            lineno: 7,
+            runID: 'run-id-two',
+        };
+
+        const testTreeData: DiscoveredTestNode = {
+            path: '/test/path/root',
+            name: 'RootTest',
+            type_: 'folder',
+            id_: 'root-id',
+            children: [testItem1, testItem2],
+        };
+
+        const childrenAddStub = sandbox.stub();
+        const mockRootItem: TestItem = {
+            id: 'root-id',
+            children: {
+                add: childrenAddStub,
+            },
+        } as any;
+
+        const mockTestItem1: TestItem = {
+            id: 'test-one-id',
+            label: 'test_one',
+            uri: Uri.file('/test/path/test1.py'),
+            canResolveChildren: false,
+            tags: [],
+            range: new Range(new Position(2, 0), new Position(3, 0)),
+        } as any;
+        const mockTestItem2: TestItem = {
+            id: 'test-two-id',
+            label: 'test_two',
+            uri: Uri.file('/test/path/test2.py'),
+            canResolveChildren: false,
+            tags: [],
+            range: new Range(new Position(6, 0), new Position(7, 0)),
+        } as any;
+
+        createTestItemStub.onFirstCall().returns(mockTestItem1);
+        createTestItemStub.onSecondCall().returns(mockTestItem2);
+
+        // Act
+        populateTestTree(testController, testTreeData, mockRootItem, resultResolver, cancelationToken);
+
+        // Assert
+        assert.ok(createTestItemStub.calledWith('test-one-id', 'test_one', sinon.match.any));
+        assert.ok(createTestItemStub.calledWith('test-two-id', 'test_two', sinon.match.any));
+        // two test items called with mockRootItem's method childrenAddStub
+        assert.strictEqual(childrenAddStub.callCount, 2);
+        assert.deepStrictEqual(mockTestItem1.tags, [RunTestTag, DebugTestTag]);
+        assert.deepStrictEqual(mockTestItem2.tags, [RunTestTag, DebugTestTag]);
+        assert.deepStrictEqual(mockTestItem1.range, new Range(new Position(2, 0), new Position(3, 0)));
+        assert.deepStrictEqual(mockTestItem2.range, new Range(new Position(6, 0), new Position(7, 0)));
+    });
+});
diff --git a/src/test/testing/testController/workspaceTestAdapter.unit.test.ts b/src/test/testing/testController/workspaceTestAdapter.unit.test.ts
index 9a07d4451e85..6d2895ca2979 100644
--- a/src/test/testing/testController/workspaceTestAdapter.unit.test.ts
+++ b/src/test/testing/testController/workspaceTestAdapter.unit.test.ts
@@ -6,7 +6,7 @@ import * as sinon from 'sinon';
 import * as typemoq from 'typemoq';
 
 import { TestController, TestItem, TestItemCollection, TestRun, Uri } from 'vscode';
-import { IConfigurationService, ITestOutputChannel } from '../../../client/common/types';
+import { IConfigurationService } from '../../../client/common/types';
 import { UnittestTestDiscoveryAdapter } from '../../../client/testing/testController/unittest/testDiscoveryAdapter';
 import { UnittestTestExecutionAdapter } from '../../../client/testing/testController/unittest/testExecutionAdapter'; // 7/7
 import { WorkspaceTestAdapter } from '../../../client/testing/testController/workspaceTestAdapter';
@@ -25,7 +25,6 @@ suite('Workspace test adapter', () => {
 
         let discoverTestsStub: sinon.SinonStub;
         let sendTelemetryStub: sinon.SinonStub;
-        let outputChannel: typemoq.IMock<ITestOutputChannel>;
 
         let telemetryEvent: { eventName: EventName; properties: Record<string, unknown> }[] = [];
         let execFactory: typemoq.IMock<IPythonExecutionFactory>;
@@ -106,7 +105,6 @@ suite('Workspace test adapter', () => {
 
             discoverTestsStub = sinon.stub(UnittestTestDiscoveryAdapter.prototype, 'discoverTests');
             sendTelemetryStub = sinon.stub(Telemetry, 'sendTelemetryEvent').callsFake(mockSendTelemetryEvent);
-            outputChannel = typemoq.Mock.ofType<ITestOutputChannel>();
         });
 
         teardown(() => {
@@ -119,8 +117,8 @@ suite('Workspace test adapter', () => {
         test('If discovery failed correctly create error node', async () => {
             discoverTestsStub.rejects(new Error('foo'));
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
             const uriFoo = Uri.parse('foo');
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
@@ -149,7 +147,7 @@ suite('Workspace test adapter', () => {
             const testProvider = 'unittest';
 
             execFactory = typemoq.Mock.ofType<IPythonExecutionFactory>();
-            await workspaceTestAdapter.discoverTests(testController, undefined, execFactory.object);
+            await workspaceTestAdapter.discoverTests(testController, execFactory.object);
 
             sinon.assert.calledWithMatch(createErrorTestItemStub, sinon.match.any, sinon.match.any);
             sinon.assert.calledWithMatch(buildErrorNodeOptionsStub, uriFoo, sinon.match.any, testProvider);
@@ -158,8 +156,8 @@ suite('Workspace test adapter', () => {
         test("When discovering tests, the workspace test adapter should call the test discovery adapter's discoverTest method", async () => {
             discoverTestsStub.resolves();
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
                 testDiscoveryAdapter,
@@ -168,7 +166,7 @@ suite('Workspace test adapter', () => {
                 stubResultResolver,
             );
 
-            await workspaceTestAdapter.discoverTests(testController, undefined, execFactory.object);
+            await workspaceTestAdapter.discoverTests(testController, execFactory.object);
 
             sinon.assert.calledOnce(discoverTestsStub);
         });
@@ -184,8 +182,8 @@ suite('Workspace test adapter', () => {
                     }),
             );
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
                 testDiscoveryAdapter,
@@ -195,8 +193,8 @@ suite('Workspace test adapter', () => {
             );
 
             // Try running discovery twice
-            const one = workspaceTestAdapter.discoverTests(testController);
-            const two = workspaceTestAdapter.discoverTests(testController);
+            const one = workspaceTestAdapter.discoverTests(testController, execFactory.object);
+            const two = workspaceTestAdapter.discoverTests(testController, execFactory.object);
 
             Promise.all([one, two]);
 
@@ -206,8 +204,8 @@ suite('Workspace test adapter', () => {
         test('If discovery succeeds, send a telemetry event with the "failed" key set to false', async () => {
             discoverTestsStub.resolves({ status: 'success' });
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
 
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
@@ -217,7 +215,7 @@ suite('Workspace test adapter', () => {
                 stubResultResolver,
             );
 
-            await workspaceTestAdapter.discoverTests(testController, undefined, execFactory.object);
+            await workspaceTestAdapter.discoverTests(testController, execFactory.object);
 
             sinon.assert.calledWith(sendTelemetryStub, EventName.UNITTEST_DISCOVERY_DONE);
             assert.strictEqual(telemetryEvent.length, 2);
@@ -229,8 +227,8 @@ suite('Workspace test adapter', () => {
         test('If discovery failed, send a telemetry event with the "failed" key set to true, and add an error node to the test controller', async () => {
             discoverTestsStub.rejects(new Error('foo'));
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
 
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
@@ -240,7 +238,7 @@ suite('Workspace test adapter', () => {
                 stubResultResolver,
             );
 
-            await workspaceTestAdapter.discoverTests(testController);
+            await workspaceTestAdapter.discoverTests(testController, execFactory.object);
 
             sinon.assert.calledWith(sendTelemetryStub, EventName.UNITTEST_DISCOVERY_DONE);
             assert.strictEqual(telemetryEvent.length, 2);
@@ -254,11 +252,11 @@ suite('Workspace test adapter', () => {
         let stubResultResolver: ITestResultResolver;
         let executionTestsStub: sinon.SinonStub;
         let sendTelemetryStub: sinon.SinonStub;
-        let outputChannel: typemoq.IMock<ITestOutputChannel>;
         let runInstance: typemoq.IMock<TestRun>;
         let testControllerMock: typemoq.IMock<TestController>;
         let telemetryEvent: { eventName: EventName; properties: Record<string, unknown> }[] = [];
         let resultResolver: ResultResolver.PythonResultResolver;
+        let execFactory: typemoq.IMock<IPythonExecutionFactory>;
 
         // Stubbed test controller (see comment around L.40)
         let testController: TestController;
@@ -331,7 +329,7 @@ suite('Workspace test adapter', () => {
 
             executionTestsStub = sandbox.stub(UnittestTestExecutionAdapter.prototype, 'runTests');
             sendTelemetryStub = sandbox.stub(Telemetry, 'sendTelemetryEvent').callsFake(mockSendTelemetryEvent);
-            outputChannel = typemoq.Mock.ofType<ITestOutputChannel>();
+            execFactory = typemoq.Mock.ofType<IPythonExecutionFactory>();
             runInstance = typemoq.Mock.ofType<TestRun>();
 
             const testProvider = 'pytest';
@@ -346,8 +344,8 @@ suite('Workspace test adapter', () => {
             sandbox.restore();
         });
         test('When executing tests, the right tests should be sent to be executed', async () => {
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
                 testDiscoveryAdapter,
@@ -388,14 +386,19 @@ suite('Workspace test adapter', () => {
             testControllerMock = typemoq.Mock.ofType<TestController>();
             testControllerMock.setup((t) => t.items).returns(() => testItemCollectionMock.object);
 
-            await workspaceTestAdapter.executeTests(testController, runInstance.object, [mockTestItem1, mockTestItem2]);
+            await workspaceTestAdapter.executeTests(
+                testController,
+                runInstance.object,
+                [mockTestItem1, mockTestItem2],
+                execFactory.object,
+            );
 
             runInstance.verify((r) => r.started(typemoq.It.isAny()), typemoq.Times.exactly(2));
         });
 
         test("When executing tests, the workspace test adapter should call the test execute adapter's executionTest method", async () => {
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
                 testDiscoveryAdapter,
@@ -404,7 +407,7 @@ suite('Workspace test adapter', () => {
                 stubResultResolver,
             );
 
-            await workspaceTestAdapter.executeTests(testController, runInstance.object, []);
+            await workspaceTestAdapter.executeTests(testController, runInstance.object, [], execFactory.object);
 
             sinon.assert.calledOnce(executionTestsStub);
         });
@@ -420,8 +423,8 @@ suite('Workspace test adapter', () => {
                     }),
             );
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
                 testDiscoveryAdapter,
@@ -431,8 +434,8 @@ suite('Workspace test adapter', () => {
             );
 
             // Try running discovery twice
-            const one = workspaceTestAdapter.executeTests(testController, runInstance.object, []);
-            const two = workspaceTestAdapter.executeTests(testController, runInstance.object, []);
+            const one = workspaceTestAdapter.executeTests(testController, runInstance.object, [], execFactory.object);
+            const two = workspaceTestAdapter.executeTests(testController, runInstance.object, [], execFactory.object);
 
             Promise.all([one, two]);
 
@@ -442,8 +445,8 @@ suite('Workspace test adapter', () => {
         test('If execution failed correctly create error node', async () => {
             executionTestsStub.rejects(new Error('foo'));
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
 
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
@@ -471,7 +474,7 @@ suite('Workspace test adapter', () => {
             const buildErrorNodeOptionsStub = sinon.stub(util, 'buildErrorNodeOptions').returns(errorTestItemOptions);
             const testProvider = 'unittest';
 
-            await workspaceTestAdapter.executeTests(testController, runInstance.object, []);
+            await workspaceTestAdapter.executeTests(testController, runInstance.object, [], execFactory.object);
 
             sinon.assert.calledWithMatch(createErrorTestItemStub, sinon.match.any, sinon.match.any);
             sinon.assert.calledWithMatch(buildErrorNodeOptionsStub, Uri.parse('foo'), sinon.match.any, testProvider);
@@ -480,8 +483,8 @@ suite('Workspace test adapter', () => {
         test('If execution failed, send a telemetry event with the "failed" key set to true, and add an error node to the test controller', async () => {
             executionTestsStub.rejects(new Error('foo'));
 
-            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings, outputChannel.object);
-            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings, outputChannel.object);
+            const testDiscoveryAdapter = new UnittestTestDiscoveryAdapter(stubConfigSettings);
+            const testExecutionAdapter = new UnittestTestExecutionAdapter(stubConfigSettings);
 
             const workspaceTestAdapter = new WorkspaceTestAdapter(
                 'unittest',
@@ -491,7 +494,7 @@ suite('Workspace test adapter', () => {
                 stubResultResolver,
             );
 
-            await workspaceTestAdapter.executeTests(testController, runInstance.object, []);
+            await workspaceTestAdapter.executeTests(testController, runInstance.object, [], execFactory.object);
 
             sinon.assert.calledWith(sendTelemetryStub, EventName.UNITTEST_RUN_ALL_FAILED);
             assert.strictEqual(telemetryEvent.length, 1);
diff --git a/src/test/testing/utils.unit.test.ts b/src/test/testing/utils.unit.test.ts
new file mode 100644
index 000000000000..8efa0cee0e65
--- /dev/null
+++ b/src/test/testing/utils.unit.test.ts
@@ -0,0 +1,51 @@
+import { expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import * as utils from '../../client/testing/utils';
+import sinon from 'sinon';
+use(chaiAsPromised.default);
+
+function test_idToModuleClassMethod() {
+    try {
+        expect(utils.idToModuleClassMethod('foo')).to.equal('foo');
+        expect(utils.idToModuleClassMethod('a/b/c.pyMyClass')).to.equal('c.MyClass');
+        expect(utils.idToModuleClassMethod('a/b/c.pyMyClassmy_method')).to.equal('c.MyClass.my_method');
+        expect(utils.idToModuleClassMethod('\\MyClass')).to.be.undefined;
+        console.log('test_idToModuleClassMethod passed');
+    } catch (e) {
+        console.error('test_idToModuleClassMethod failed:', e);
+    }
+}
+
+async function test_writeTestIdToClipboard() {
+    let clipboardStub = sinon.stub(utils, 'clipboardWriteText').resolves();
+    const { writeTestIdToClipboard } = utils;
+    try {
+        // unittest id
+        const testItem = { id: 'a/b/c.pyMyClass\\my_method' };
+        await writeTestIdToClipboard(testItem as any);
+        sinon.assert.calledOnceWithExactly(clipboardStub, 'c.MyClass.my_method');
+        clipboardStub.resetHistory();
+
+        // pytest id
+        const testItem2 = { id: 'tests/test_foo.py::TestClass::test_method' };
+        await writeTestIdToClipboard(testItem2 as any);
+        sinon.assert.calledOnceWithExactly(clipboardStub, 'tests/test_foo.py::TestClass::test_method');
+        clipboardStub.resetHistory();
+
+        // undefined
+        await writeTestIdToClipboard(undefined as any);
+        sinon.assert.notCalled(clipboardStub);
+
+        console.log('test_writeTestIdToClipboard passed');
+    } catch (e) {
+        console.error('test_writeTestIdToClipboard failed:', e);
+    } finally {
+        sinon.restore();
+    }
+}
+
+// Run tests
+(async () => {
+    test_idToModuleClassMethod();
+    await test_writeTestIdToClipboard();
+})();
diff --git a/src/test/vscode-mock.ts b/src/test/vscode-mock.ts
index 0605b1718166..b7ea2bc549a0 100644
--- a/src/test/vscode-mock.ts
+++ b/src/test/vscode-mock.ts
@@ -7,6 +7,7 @@ import * as vscode from 'vscode';
 import * as vscodeMocks from './mocks/vsc';
 import { vscMockTelemetryReporter } from './mocks/vsc/telemetryReporter';
 import { anything, instance, mock, when } from 'ts-mockito';
+import { TestItem } from 'vscode';
 const Module = require('module');
 
 type VSCode = typeof vscode;
@@ -134,3 +135,43 @@ mockedVSCode.LogLevel = vscodeMocks.LogLevel;
 (mockedVSCode as any).CancellationError = vscodeMocks.vscMockExtHostedTypes.CancellationError;
 (mockedVSCode as any).LSPCancellationError = vscodeMocks.vscMockExtHostedTypes.LSPCancellationError;
 mockedVSCode.TestRunProfileKind = vscodeMocks.TestRunProfileKind;
+(mockedVSCode as any).TestCoverageCount = class TestCoverageCount {
+    constructor(public covered: number, public total: number) {}
+};
+(mockedVSCode as any).FileCoverage = class FileCoverage {
+    constructor(
+        public uri: any,
+        public statementCoverage: any,
+        public branchCoverage?: any,
+        public declarationCoverage?: any,
+    ) {}
+};
+(mockedVSCode as any).StatementCoverage = class StatementCoverage {
+    constructor(public executed: number | boolean, public location: any, public branches?: any) {}
+};
+
+// Mock TestController for vscode.tests namespace
+function createMockTestController(): vscode.TestController {
+    const disposable = { dispose: () => undefined };
+    return ({
+        items: {
+            forEach: () => undefined,
+            get: () => undefined,
+            add: () => undefined,
+            replace: () => undefined,
+            delete: () => undefined,
+            size: 0,
+            [Symbol.iterator]: function* () {},
+        },
+        createRunProfile: () => disposable,
+        createTestItem: () => ({} as TestItem),
+        dispose: () => undefined,
+        resolveHandler: undefined,
+        refreshHandler: undefined,
+    } as unknown) as vscode.TestController;
+}
+
+// Add tests namespace with createTestController
+(mockedVSCode as any).tests = {
+    createTestController: (_id: string, _label: string) => createMockTestController(),
+};