[automated] Merge branch 'main' => 'release/dnup'

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "microsoft.dotnet.helix.jobmonitor": {
-      "version": "11.0.0-beta.26365.101",
+      "version": "11.0.0-beta.26405.103",
       "commands": [
         "dotnet-helix-job-monitor"
       ]

.github/aw/actions-lock.json

@@ -25,10 +25,10 @@
       "version": "v7.0.1",
       "sha": "043fb46d1a93c77aae656e7c1c64a875d1fc6a0a"
     },
-    "github/gh-aw-actions/setup@v0.82.9": {
+    "github/gh-aw-actions/setup@v0.83.1": {
       "repo": "github/gh-aw-actions/setup",
-      "version": "v0.82.9",
-      "sha": "ca8678ca22a7aab577514482576720da641e5661"
+      "version": "v0.83.1",
+      "sha": "8bdba8075360648fe6802302a5b4e016361dc6ac"
     }
   }
 }

.github/copilot-instructions.md

@@ -141,7 +141,7 @@ Canonical scenarios:
   - The built SDK is output to `artifacts/bin/redist/<configuration>/dotnet` (`Debug` by default).
   - The first build is slow; subsequent builds are incremental.
 - Run tests: prefer targeted runs — a single test project or test (see the
-  [Testing](#testing) section) and the `incremental-test` skill. `build.cmd -test` /
+  [Testing](#testing) section) and the `targeted-test` skill. `build.cmd -test` /
   `./build.sh --test` runs the **entire** suite, which is very large and takes a long time;
   avoid running the full suite for routine local or agent work.
 - Release build: `build.cmd -c Release`.
@@ -150,8 +150,10 @@ Canonical scenarios:
   See the [Testing](#testing) section for assembly filtering and more examples.
 - Validate changes locally using the SDK you built at
   `artifacts/bin/redist/<configuration>/dotnet` (`Debug` by default).
-- For fast inner-loop runs of `dotnet.Tests` without a full rebuild, use the
-  `incremental-test` skill.
+- Use the `targeted-test` skill to select projects from the shared
+  `test/ConditionalTests.props` scopes when available and retain detailed failure output,
+  a TRX, and a binlog. For fast inner-loop runs of `dotnet.Tests` without a full rebuild,
+  use `incremental-test`.
 
 ## Guardrails
 
@@ -172,6 +174,21 @@ manually edit:
 - **Generated workflow lock files** (`.github/workflows/*.lock.yml`).
 - More broadly, any file marked `linguist-generated=true` in `.gitattributes`.
 
+### Preserve CI telemetry correlation
+
+Set `DOTNET_CLI_TELEMETRY_SESSIONID` in every CI workflow and pipeline entry point. Set
+the variable at the workflow or pipeline scope. Job scope is valid for a single-job
+workflow. Use the applicable value without changes:
+
+- GitHub Actions:
+  `gha-${{ github.repository_id }}-${{ github.run_id }}-${{ github.run_attempt }}`
+- Azure DevOps:
+  `azdo-$(System.CollectionId)-$(System.TeamProjectId)-$(Build.BuildId)`
+
+When you change shared CI environment variables, preserve this variable. See
+the [developer guide](../documentation/project-docs/developer-guide.md#ci-workflow-telemetry-correlation)
+for the required YAML and the reason for this variable.
+
 ## External Dependencies
 
 Adding or updating a dependency is a repo-wide compatibility and supply-chain change,
@@ -228,6 +245,10 @@ property:
 
 - Large changes should always include test changes.
 - The Skip parameter of the Fact attribute to point to the specific issue link.
+- Use the `targeted-test` skill to choose projects from `test/ConditionalTests.props`
+  when the changed paths match a configured scope, or use its fallback mappings for
+  unscoped common areas. Run one project, class, or method with detailed live output and
+  retained TRX/binlog diagnostics.
 - To run tests in this repo (after a full build, invoke the repo-local bootstrap SDK directly):
   - For MSTest-style projects: `./.dotnet/dotnet test path/to/project.csproj --filter "FullyQualifiedName~TestName"`
   - To run a built test assembly directly: `./.dotnet/dotnet exec artifacts/bin/redist/Debug/TestAssembly.dll --filter "TestMethodName"`

.github/skills/ValidateSkill.cs

@@ -1,4 +1,8 @@
 #!/usr/bin/env dotnet
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
 #:property ManagePackageVersionsCentrally=false
 #:property PublishAot=false
 #:package YamlDotNet@16.3.0

.github/skills/add-dotnet-aot-command/SKILL.md

@@ -44,6 +44,12 @@ Dispatch: `dotnet-aot/NativeEntryPoint.cs` (`dotnet_execute`) is P/Invoked by th
 - `DOTNET_CLI_ENABLEAOT=true`: parse in-process, run `FirstRunExperience.Setup`, and if
   `parseResult.CanBeInvoked()` run the command **in-process**. A command still needing the managed CLI
   throws `CommandNotAvailableInAotException` to fall through.
+- `run` has an intentionally narrow AOT path: launch-only reuse through explicit `--file`,
+  positional discovery, or implicit shorthand. `--no-build` can use prior synthetic output;
+  build-enabled and no-build runs can use unchanged validated replayed/MSBuild `RunProperties`.
+  Project profiles decorate cached launches, while no-build Executable profiles can bypass cache.
+  Positional discovery defers when the current directory contains a project; shorthand first
+  preserves external resolution. Stale, ambiguous, or build-required shapes defer.
 - Otherwise / on fall-through: host `{sdkDir}/dotnet.dll` via hostfxr (same source, JIT-compiled).
 
 Types already available (do **not** re-add their sources): `Microsoft.DotNet.Cli.Utils`,
@@ -150,12 +156,19 @@ steps** so they can reproduce it.
 src\Cli\dn\run-dn.ps1 -Command "--info"                    # through the AOT binary
 src\Cli\dn\run-dn.ps1 -Command "--info" -Mode Compare      # AOT vs managed diff (parity)
 src\Cli\dn\run-dn.ps1 -Command "workload --info" -NoBuild  # reuse the assembled layout
+src\Cli\dn\run-dn.ps1 -Command "run --file C:\tmp\app.cs --no-build --no-launch-profile" -NoBuild
+src\Cli\dn\run-dn.ps1 -Command "run C:\tmp\app.cs --no-build --no-launch-profile" -NoBuild
+src\Cli\dn\run-dn.ps1 -Command "C:\tmp\app.cs --no-build --no-launch-profile" -NoBuild
+src\Cli\dn\run-dn.ps1 -Command "run --file C:\tmp\app.cs --no-build --launch-profile MyProfile" -NoBuild
 ```
 
-- `DOTNET_CLI_ENABLEAOT=true` runs in-process in `dotnet-aot.dll`; unset, `dn` hosts the copied
-  `dotnet.dll`. `-Mode Compare` diffs the captured output (`artifacts/log/dn-aot.txt`, `dn-managed.txt`).
+- `DOTNET_CLI_ENABLEAOT=true` runs in-process in the platform-specific `dotnet-aot` native library;
+  `DOTNET_CLI_ENABLEAOT=false` makes `dn` host the copied `dotnet.dll`. `-Mode Compare` diffs the
+  captured output (`artifacts/log/dn-aot.txt`, `dn-managed.txt`).
 - `dn` finds the .NET root from `DOTNET_ROOT` (set to `.dotnet`); the publish dir isn't a full SDK.
 - The AOT path runs `FirstRunExperience.Setup` first; if it can't complete, it defers to the managed CLI.
+- For focused integration tests against an assembled harness, set
+  `DOTNET_AOT_TEST_DN_PATH` to the full `dn` executable path.
 - `Commit` and workloads reflect the `DOTNET_ROOT` layout - both paths read the same root, so they agree.
 
 The VS Code tasks `publish-and-copy-dn-aot` + `copy-all-deps` do the same build/assemble.

.github/skills/code-review/SKILL.md

@@ -110,7 +110,7 @@ Group files by area to guide how deeply to review each. The first five areas are
 | Compatibility tooling | `src/Compatibility/**` (ApiCompat/GenAPI) | Compiler/language semantic fidelity, diagnostics, generated reference output, framework variation |
 | Watch / Containers | `src/Dotnet.Watch/**`, `src/Containers/**` | Process lifetime, cancellation, file-system races, cleanup |
 | Analyzers | `src/Microsoft.CodeAnalysis.NetAnalyzers/**` | Roslyn diagnostic correctness across supported frameworks |
-| Build/Infra | `eng/**`, `Directory.Build.props`, `Directory.Build.targets`, `*.slnx` | Unintended side effects, breaking conditional logic |
+| Build/Infra | `eng/**`, `.github/workflows/**`, `.vsts*.yml`, `Directory.Build.props`, `Directory.Build.targets`, `*.slnx` | Unintended side effects, breaking conditional logic, CI telemetry correlation |
 | Tests | `test/**` | Scenario-accurate regression coverage, target/platform gating, tests that would fail without the fix |
 
 ## Step 4: Review the Code
@@ -137,6 +137,7 @@ Then read the PR description, labels, and linked issues (in PR review mode) as *
 
 - Compare *behavior*, not just shape: how leniently each accepts input, how each orders or normalizes values, and which options or flags each honors. An input the SDK accepts elsewhere should not fail here, and vice versa — flag the divergence with both file:line references (the new code and the established sibling).
 - When the new code emits output that another component must later consume (a project-file edit, a generated directive, a manifest), verify the consumer's contract is satisfied — including ordering and implicit-default semantics, not just syntactic validity.
+- For each changed CI entry point, verify the scope of `DOTNET_CLI_TELEMETRY_SESSIONID`. Require workflow or pipeline scope for multiple jobs. Permit job scope for a single-job workflow. Use the provider format from the [developer guide](../../../documentation/project-docs/developer-guide.md#ci-workflow-telemetry-correlation). Flag a missing, per-step, or changed value. These errors prevent reliable correlation between the run's `dotnet` processes.
 
 ### Impact Analysis for Tests and Regressions
 

.github/skills/incremental-test/SKILL.md

@@ -80,14 +80,11 @@ The test project `test\dotnet.Tests\dotnet.Tests.csproj` outputs directly to `ar
 
 ### Step 5: Run the tests
 
-Run specific tests:
-```
-.\.dotnet\dotnet exec artifacts\bin\redist\Debug\dotnet.Tests.dll -method "*TestMethodName*"
-```
+Use the **targeted-test** runner so failures retain detailed output, a TRX, and a
+binlog:
 
-Or run filtered tests via `dotnet test`:
-```
-.\.dotnet\dotnet test test\dotnet.Tests\dotnet.Tests.csproj --no-build --filter "Name~TestMethodName"
+```shell
+./.dotnet/dotnet .github/skills/targeted-test/scripts/RunTargetedTests.cs -- --project test/dotnet.Tests/dotnet.Tests.csproj --filter "Name~TestMethodName" --no-build
 ```
 
 ## Common project paths

.github/skills/targeted-test/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: targeted-test
+description: >-
+  Select and run the smallest relevant .NET SDK tests with live output and retained
+  TRX/binlog diagnostics. REQUIRED: invoke before answering any dotnet/sdk request
+  containing an explicit deliverable to select, run, or rerun narrow local tests. Use
+  the owning workflow for the change, then this skill for test selection and execution.
+  Also use to test a completed change, choose tests from changed files, run targeted,
+  focused, or smallest relevant tests, or run one project, class, or method, including
+  plans and dry runs. NEVER invoke when the user says not to run tests yet. DO NOT USE
+  for full suites, end-to-end validation, repo investigations, or review.
+license: MIT
+---
+
+# Targeted tests
+
+Run the smallest project and filter that cover the changed behavior. This workflow
+streams detailed test output and writes a TRX plus an MSBuild binlog under
+`artifacts/log/targeted-tests/`.
+
+## Select configured test scopes first
+
+Read `test/ConditionalTests.props` before choosing tests. Its `TriggerPaths` and
+`TestProjects` metadata are the repository's source of truth for configured areas; do
+not duplicate those mappings in this skill.
+
+For each scope whose `TriggerPaths` match the changed files, expand its project globs
+with the same evaluator used by PR validation:
+
+```powershell
+.\.dotnet\dotnet.exe run scripts\EvaluateConditionalTestScopes.cs -- `
+  --repo-root . `
+  --list-test-projects ApiCompat
+```
+
+The command writes one `Targeted test project:` line per concrete project. Run each
+project separately with the runner below. If a changed file matches
+`GlobalTriggerPaths`, the conditional system cannot safely narrow the suite; use broader
+validation instead.
+
+## Fall back for common unscoped areas
+
+When no `ConditionalTestScope` covers the changed paths, start with the project that
+owns the changed behavior. If a change crosses areas, run each relevant project
+separately so a failure identifies the affected area. This table is intentionally
+limited to common areas rather than being an exhaustive test-project catalog.
+
+| Change area | Primary test project |
+| --- | --- |
+| Managed CLI commands, parsing, help, and workloads | `test/dotnet.Tests/dotnet.Tests.csproj` |
+| CLI utilities | `test/Microsoft.DotNet.Cli.Utils.Tests/Microsoft.DotNet.Cli.Utils.Tests.csproj` |
+| SDK build targets and NETSDK diagnostics | `test/Microsoft.NET.Build.Tests/Microsoft.NET.Build.Tests.csproj` |
+| Build task unit behavior | `test/Microsoft.NET.Build.Tasks.Tests/Microsoft.NET.Build.Tasks.Tests.csproj` |
+| Publish | `test/Microsoft.NET.Publish.Tests/Microsoft.NET.Publish.Tests.csproj` |
+| Pack | `test/Microsoft.NET.Pack.Tests/Microsoft.NET.Pack.Tests.csproj` |
+| Restore | `test/Microsoft.NET.Restore.Tests/Microsoft.NET.Restore.Tests.csproj` |
+| MSBuild SDK resolution | `test/Microsoft.DotNet.MSBuildSdkResolver.Tests/Microsoft.DotNet.MSBuildSdkResolver.Tests.csproj` |
+| Containers | `test/Microsoft.NET.Build.Containers.UnitTests/Microsoft.NET.Build.Containers.UnitTests.csproj` |
+| Containers with registry/runtime behavior | `test/Microsoft.NET.Build.Containers.IntegrationTests/Microsoft.NET.Build.Containers.IntegrationTests.csproj` |
+| `dotnet watch` | `test/dotnet-watch.Tests/dotnet-watch.Tests.csproj` |
+| Static Web Assets | `test/Microsoft.NET.Sdk.StaticWebAssets.Tests/Microsoft.NET.Sdk.StaticWebAssets.Tests.csproj` |
+| Web SDK | `test/Microsoft.NET.Sdk.Web.Tests/Microsoft.NET.Sdk.Web.Tests.csproj` |
+| Razor SDK | `test/Microsoft.NET.Sdk.Razor.Tests/Microsoft.NET.Sdk.Razor.Tests.csproj` |
+| Blazor WebAssembly SDK | `test/Microsoft.NET.Sdk.BlazorWebAssembly.Tests/Microsoft.NET.Sdk.BlazorWebAssembly.Tests.csproj` |
+
+Keep this fallback table limited to areas not represented in
+`test/ConditionalTests.props`. Whenever that file changes, reconcile this table: remove
+entries for areas that are now configured, and update entries when test-project ownership
+changes. Do not duplicate configured mappings here; add or change them in the props file
+so local agent selection and PR filtering stay aligned.
+
+Also revisit this table when adding a test project for a substantive new area. Prefer a
+`ConditionalTestScope` when reliable trigger paths can be defined. When the area is too
+broad for practical conditional filtering, add its primary test project to this table.
+
+## Make the product output current
+
+Tests exercise the SDK under `artifacts/bin/redist/<Configuration>/dotnet`, not only
+assemblies built beside the test project.
+
+1. If the redist layout does not exist, run `build.cmd` on Windows or `./build.sh` on
+   macOS/Linux.
+2. If production code changed, ensure the redist layout contains that change before
+   trusting the result:
+   - For managed CLI changes covered by `dotnet.Tests`, use **incremental-test** to build
+     and deploy the changed assemblies without a full rebuild.
+   - For Static Web Assets implementation changes, use
+     **validate-static-web-asset-change**.
+   - Otherwise rebuild the repository. Building only a test project can leave the SDK
+     under test stale even when the test assembly itself is current.
+3. If only test code changed, the runner can build the selected test project directly.
+
+## Run
+
+Start with a build-producing run. The runner builds the selected project by default,
+which keeps the test assembly current and produces the binlog needed to diagnose build
+failures. Add `--no-build` only after this session built that exact project after the
+latest test-code change and confirmed its expected output exists. Do not infer readiness
+from another project or an older artifact; when uncertain, omit `--no-build`.
+
+From the repository root on Windows:
+
+```powershell
+.\.dotnet\dotnet.exe .github\skills\targeted-test\scripts\RunTargetedTests.cs -- `
+  --project test\Microsoft.NET.Build.Tests\Microsoft.NET.Build.Tests.csproj `
+  --filter "FullyQualifiedName~GivenThatWeWantToBuildALibrary"
+```
+
+On macOS/Linux:
+
+```bash
+./.dotnet/dotnet .github/skills/targeted-test/scripts/RunTargetedTests.cs -- \
+  --project test/Microsoft.NET.Build.Tests/Microsoft.NET.Build.Tests.csproj \
+  --filter "FullyQualifiedName~GivenThatWeWantToBuildALibrary"
+```
+
+Omit `--filter` to run the whole project. Use `--configuration Release` when validating
+a Release redist layout. A `--no-build` run does not produce a new build binlog.
+
+The runner evaluates the project to select its test platform. It executes MSTest.Sdk
+projects through their built Microsoft.Testing.Platform executable and keeps
+`dotnet test` for other projects. It prints the exact command before execution. On
+failure it also prints failed test names when a TRX is available, the retained
+TRX/binlog paths, and the rerun command. Do not replace it with a command that
+suppresses console output or discards those artifacts.