diff --git a/.github/instructions/testing_feature_area.instructions.md b/.github/instructions/testing_feature_area.instructions.md
index be946e798dff..a4e11523d7c8 100644
--- a/.github/instructions/testing_feature_area.instructions.md
+++ b/.github/instructions/testing_feature_area.instructions.md
@@ -159,8 +159,6 @@ The adapters in the extension don't implement test discovery/run logic themselve
 
 Project-based testing enables multi-project workspace support where each Python project gets its own test tree root with its own Python environment.
 
-> **⚠️ Note: unittest support for project-based testing is NOT yet implemented.** Project-based testing currently only works with pytest. unittest support will be added in a future PR.
-
 ### Architecture
 
 -   **TestProjectRegistry** (`testProjectRegistry.ts`): Central registry that:
@@ -182,8 +180,30 @@ Project-based testing enables multi-project workspace support where each Python
 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**: `get_test_root_path()` in `vscode_pytest/__init__.py` returns `PROJECT_ROOT_PATH` (if set) or falls back to `cwd`.
-6. **Test tree**: Each project gets its own root node in the Test Explorer, with test IDs scoped by project ID using the `||` separator.
+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
 
@@ -191,14 +211,21 @@ All project-based testing logs use the `[test-by-project]` prefix for easy filte
 
 ### Key files
 
--   Python side: `python_files/vscode_pytest/__init__.py` — `get_test_root_path()` function and `PROJECT_ROOT_PATH` environment variable.
--   TypeScript: `testProjectRegistry.ts`, `projectAdapter.ts`, `projectUtils.ts`, and the discovery adapters.
+-   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_get_test_root_path.py` — Python-side get_test_root_path() 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)
 
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/unittestadapter/discovery.py b/python_files/unittestadapter/discovery.py
index ce8251218743..b3086d92b102 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,19 @@ 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
+            print(
+                f"PROJECT_ROOT_PATH is set, using {project_root_path} as top_level_dir for discovery"
+            )
+
         # 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/execution.py b/python_files/unittestadapter/execution.py
index 951289850884..e031138b6f75 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):
@@ -191,8 +194,22 @@ def run_tests(
     verbosity: int,
     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
@@ -348,7 +366,19 @@ def send_run_data(raw_data, test_run_pipe):
         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
+            print(
+                f"PROJECT_ROOT_PATH is set, using {project_root_path} as cwd for execution payload"
+            )
+
         # Perform regular unittest execution.
+        # Pass project_root_path so the payload's cwd matches the project root.
         payload = run_tests(
             start_dir,
             test_ids,
@@ -357,6 +387,7 @@ def send_run_data(raw_data, test_run_pipe):
             verbosity,
             failfast,
             locals_,
+            project_root_path=project_root_path,
         )
 
     if is_coverage_run:
diff --git a/src/client/testing/testController/common/resultResolver.ts b/src/client/testing/testController/common/resultResolver.ts
index 2e843a571095..c126d233de1b 100644
--- a/src/client/testing/testController/common/resultResolver.ts
+++ b/src/client/testing/testController/common/resultResolver.ts
@@ -33,15 +33,23 @@ export class PythonResultResolver implements ITestResultResolver {
      */
     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.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();
     }
@@ -76,6 +84,7 @@ export class PythonResultResolver implements ITestResultResolver {
             this.testProvider,
             token,
             this.projectId,
+            this.projectName,
         );
         sendTelemetryEvent(EventName.UNITTEST_DISCOVERY_DONE, undefined, {
             tool: this.testProvider,
diff --git a/src/client/testing/testController/common/testDiscoveryHandler.ts b/src/client/testing/testController/common/testDiscoveryHandler.ts
index 212818bc070f..97f65123911a 100644
--- a/src/client/testing/testController/common/testDiscoveryHandler.ts
+++ b/src/client/testing/testController/common/testDiscoveryHandler.ts
@@ -29,6 +29,7 @@ export class TestDiscoveryHandler {
         testProvider: TestProvider,
         token?: CancellationToken,
         projectId?: string,
+        projectName?: string,
     ): void {
         if (!payload) {
             // No test data is available
@@ -70,6 +71,7 @@ export class TestDiscoveryHandler {
                 },
                 token,
                 projectId,
+                projectName,
             );
         }
     }
diff --git a/src/client/testing/testController/common/testProjectRegistry.ts b/src/client/testing/testController/common/testProjectRegistry.ts
index 458ac93ffd08..6236bf822c32 100644
--- a/src/client/testing/testController/common/testProjectRegistry.ts
+++ b/src/client/testing/testController/common/testProjectRegistry.ts
@@ -192,7 +192,14 @@ export class TestProjectRegistry {
 
         // Create test infrastructure
         const testProvider = this.getTestProvider(workspaceUri);
-        const resultResolver = new PythonResultResolver(this.testController, testProvider, workspaceUri, projectId);
+        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,
@@ -200,10 +207,8 @@ export class TestProjectRegistry {
             this.envVarsService,
         );
 
-        const projectName = createProjectDisplayName(pythonProject.name, pythonEnvironment.version);
-
         return {
-            projectName,
+            projectName: projectDisplayName,
             projectUri: pythonProject.uri,
             workspaceUri,
             pythonProject,
diff --git a/src/client/testing/testController/common/types.ts b/src/client/testing/testController/common/types.ts
index 6af18c8422c9..017c41cf3d97 100644
--- a/src/client/testing/testController/common/types.ts
+++ b/src/client/testing/testController/common/types.ts
@@ -183,6 +183,7 @@ export interface ITestExecutionAdapter {
         executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void>;
 }
 
diff --git a/src/client/testing/testController/common/utils.ts b/src/client/testing/testController/common/utils.ts
index dd7e396ecf24..ec26aa6b0c70 100644
--- a/src/client/testing/testController/common/utils.ts
+++ b/src/client/testing/testController/common/utils.ts
@@ -213,12 +213,15 @@ export function populateTestTree(
     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) {
         // Create project-scoped ID if projectId is provided
         const rootId = projectId ? `${projectId}${PROJECT_ID_SEPARATOR}${testTreeData.path}` : testTreeData.path;
-        testRoot = testController.createTestItem(rootId, testTreeData.name, Uri.file(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];
@@ -282,7 +285,7 @@ export function populateTestTree(
 
                     testRoot!.children.add(node);
                 }
-                populateTestTree(testController, child, node, testItemMappings, token, projectId);
+                populateTestTree(testController, child, node, testItemMappings, token, projectId, projectName);
             }
         }
     });
diff --git a/src/client/testing/testController/pytest/pytestExecutionAdapter.ts b/src/client/testing/testController/pytest/pytestExecutionAdapter.ts
index 3b2f9f7de33a..6c950ec7e01b 100644
--- a/src/client/testing/testController/pytest/pytestExecutionAdapter.ts
+++ b/src/client/testing/testController/pytest/pytestExecutionAdapter.ts
@@ -21,6 +21,7 @@ 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(
@@ -37,6 +38,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
         executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         const deferredTillServerClose: Deferred<void> = utils.createTestingDeferred();
 
@@ -71,6 +73,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
                 executionFactory,
                 debugLauncher,
                 interpreter,
+                project,
             );
         } finally {
             await deferredTillServerClose.promise;
@@ -87,6 +90,7 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
         executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<ExecutionTestPayload> {
         const relativePathToPytest = 'python_files';
         const fullPluginPath = path.join(EXTENSION_ROOT_DIR, relativePathToPytest);
@@ -102,6 +106,13 @@ 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';
         }
diff --git a/src/client/testing/testController/unittest/testDiscoveryAdapter.ts b/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
index 7c986e95a449..48c688839500 100644
--- a/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
+++ b/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
@@ -18,6 +18,7 @@ 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';
 
 /**
  * Configures the subprocess environment for unittest discovery.
@@ -51,6 +52,7 @@ export class UnittestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
         executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         // Setup discovery pipe and cancellation
         const {
@@ -78,6 +80,14 @@ export class UnittestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
             // 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`,
+                );
+            }
+
             // Setup process handlers (shared by both execution paths)
             const handlers = createProcessHandlers('unittest', uri, cwd, this.resultResolver, deferredTillExecClose);
 
diff --git a/src/client/testing/testController/unittest/testExecutionAdapter.ts b/src/client/testing/testController/unittest/testExecutionAdapter.ts
index cbc1d2985f84..85f09cd0b1f5 100644
--- a/src/client/testing/testController/unittest/testExecutionAdapter.ts
+++ b/src/client/testing/testController/unittest/testExecutionAdapter.ts
@@ -27,6 +27,7 @@ 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 { ProjectAdapter } from '../common/projectAdapter';
 
 /**
  * Wrapper Class for unittest test execution. This is where we call `runTestCommand`?
@@ -46,6 +47,8 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
         runInstance: TestRun,
         executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
+        _interpreter?: unknown, // Not used - kept for interface compatibility
+        project?: ProjectAdapter,
     ): Promise<void> {
         // deferredTillServerClose awaits named pipe server close
         const deferredTillServerClose: Deferred<void> = utils.createTestingDeferred();
@@ -80,6 +83,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
                 profileKind,
                 executionFactory,
                 debugLauncher,
+                project,
             );
         } catch (error) {
             traceError(`Error in running unittest tests: ${error}`);
@@ -97,6 +101,7 @@ export class UnittestTestExecutionAdapter implements ITestExecutionAdapter {
         profileKind: boolean | TestRunProfileKind | undefined,
         executionFactory: IPythonExecutionFactory,
         debugLauncher?: ITestDebugLauncher,
+        project?: ProjectAdapter,
     ): Promise<ExecutionTestPayload> {
         const settings = this.configSettings.getSettings(uri);
         const { unittestArgs } = settings.testing;
@@ -111,6 +116,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;
         }
diff --git a/src/client/testing/testController/workspaceTestAdapter.ts b/src/client/testing/testController/workspaceTestAdapter.ts
index 75b9489f708e..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.
@@ -47,6 +48,7 @@ export class WorkspaceTestAdapter {
         profileKind?: boolean | TestRunProfileKind,
         debugLauncher?: ITestDebugLauncher,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         if (this.executing) {
             traceError('Test execution already in progress, not starting a new one.');
@@ -84,6 +86,7 @@ export class WorkspaceTestAdapter {
                 executionFactory,
                 debugLauncher,
                 interpreter,
+                project,
             );
             deferred.resolve();
         } catch (ex) {
diff --git a/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts b/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts
index 4dae070bccbe..031f30afba8a 100644
--- a/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts
+++ b/src/test/testing/testController/unittest/testDiscoveryAdapter.unit.test.ts
@@ -22,6 +22,7 @@ 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;
@@ -244,4 +245,98 @@ suite('Unittest test discovery adapter', () => {
         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 ab492736f0ad..df104b01b548 100644
--- a/src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts
+++ b/src/test/testing/testController/unittest/testExecutionAdapter.unit.test.ts
@@ -22,6 +22,7 @@ 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';
 
 suite('Unittest test execution adapter', () => {
     let configService: IConfigurationService;
@@ -321,4 +322,116 @@ 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(),
+        );
+    });
 });