From fbce609c1d70874a9aa3d1b30506177395811fce Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 26 May 2026 19:07:58 -0400
Subject: [PATCH 01/15] refactor(cli): rename install-route identifiers to
 install-source
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rename the C# identifiers, prose, file names, and xmldoc references that
spoke of an "install route" to "install source" so the codebase matches
the on-disk sidecar field name (`{"source":"..."}`) which has always
been the authoritative spelling.

Mechanical rename only. No behavior change. Wire strings are unchanged:
`script`, `pr`, `winget`, `brew`, `dotnet-tool`, `localhive` all stay
literal; the sidecar JSON field name was already `source`.

Notable identifier renames:

- `InstallSource.Brew` enum value → `InstallSource.Homebrew` (the wire
  string stays `"brew"` via the preserved `InstallSourceExtensions.BrewWire`
  constant — only the C# enum name and the friendlier display label change).
- `InstallationInfo.Route` property → `InstallationInfo.Source` (and the
  associated `[JsonPropertyName("route")]` → `"source"`; this surface
  was added earlier in the branch and has not shipped).
- `CliPathHelper.TryGetAspireHomeDirectoryFromInstallRoute` →
  `TryGetAspireHomeDirectoryFromInstallSource`.
- `docs/specs/install-routes.md` → `docs/specs/install-sources.md`.
- `tests/.../BundleServiceCrossRouteExtractionTests.cs` →
  `BundleServiceCrossSourceExtractionTests.cs` and the contained
  theory method's name.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/dogfooding-pull-requests.md              |  8 +--
 eng/clipack/Common.projitems                  | 10 ++--
 eng/scripts/get-aspire-cli-pr.ps1             | 22 +++----
 eng/scripts/get-aspire-cli-pr.sh              | 28 ++++-----
 eng/scripts/get-aspire-cli.ps1                |  8 +--
 eng/scripts/get-aspire-cli.sh                 |  6 +-
 eng/scripts/verify-cli-archive.ps1            | 10 ++--
 eng/scripts/verify-cli-tool-nupkg.ps1         |  2 +-
 localhive.ps1                                 | 14 ++---
 localhive.sh                                  |  6 +-
 .../Acquisition/IInstallSidecarReader.cs      | 19 +++---
 .../Acquisition/IInstallationDiscovery.cs     | 10 ++--
 .../Acquisition/IPeerInstallProbe.cs          |  6 +-
 .../Acquisition/InstallSidecarReader.cs       |  4 +-
 src/Aspire.Cli/Acquisition/InstallSource.cs   | 14 ++---
 .../InstallationCandidateSources.cs           |  2 +-
 .../Acquisition/InstallationDiscovery.cs      | 46 +++++++--------
 .../Acquisition/InstallationInfo.cs           | 16 ++---
 .../Acquisition/WingetFirstRunProbe.cs        |  4 +-
 src/Aspire.Cli/Commands/SetupCommand.cs       |  8 +--
 src/Aspire.Cli/Utils/CliPathHelper.cs         |  4 +-
 .../Scripts/Common/FakeArchiveHelper.cs       |  4 +-
 .../Scripts/LocalHiveScriptFunctionTests.cs   | 12 +++-
 .../Scripts/PRScriptInstallE2ETests.cs        |  4 +-
 .../Scripts/PRScriptInstallerModeTests.cs     | 10 ++--
 .../Scripts/PRScriptPowerShellTests.cs        | 36 ++++++------
 .../Scripts/PRScriptShellTests.cs             | 40 ++++++-------
 .../Scripts/PRScriptToolModeTests.cs          | 12 ++--
 .../Scripts/ReleaseScriptPowerShellTests.cs   | 12 ++--
 .../Scripts/ReleaseScriptShellTests.cs        | 12 ++--
 .../VerifyCliArchivePowerShellTests.cs        |  6 +-
 .../Acquisition/InstallSidecarReaderTests.cs  | 12 ++--
 .../InstallationDiscoveryDiscoverAllTests.cs  | 58 +++++++++----------
 ...dleServiceComputeDefaultExtractDirTests.cs | 12 ++--
 ...undleServiceCrossSourceExtractionTests.cs} | 12 ++--
 .../Utils/CliPathHelperTests.cs               | 16 ++---
 36 files changed, 257 insertions(+), 248 deletions(-)
 rename tests/Aspire.Cli.Tests/Bundles/{BundleServiceCrossRouteExtractionTests.cs => BundleServiceCrossSourceExtractionTests.cs} (93%)

diff --git a/docs/dogfooding-pull-requests.md b/docs/dogfooding-pull-requests.md
index dafd90fe7d1..12cf09188fd 100644
--- a/docs/dogfooding-pull-requests.md
+++ b/docs/dogfooding-pull-requests.md
@@ -329,9 +329,9 @@ The file is scoped to the solution directory and only affects projects under it.
 
 The Homebrew cask (`eng/homebrew/aspire.rb.template`) installs Aspire entirely
 inside the Caskroom version directory — `brew uninstall aspire` removes
-the binary and the route sidecar end-to-end. The cask intentionally carries
-no `zap` stanza, because `~/.aspire/` is a shared prefix with the script-route
-and PR-route installers and a brew-driven recursive delete would clobber state
+the binary and the source sidecar end-to-end. The cask intentionally carries
+no `zap` stanza, because `~/.aspire/` is a shared prefix with the script-source
+and PR-source installers and a brew-driven recursive delete would clobber state
 those installers still own.
 
 If you installed via the Homebrew cask before this change, you may have a
@@ -343,7 +343,7 @@ Clean it up manually once after upgrading the cask:
 rm -rf ~/.aspire/installs/brew-stable
 ```
 
-NuGet hives under `~/.aspire/hives/` and any script-route or PR-route
+NuGet hives under `~/.aspire/hives/` and any script-source or PR-source
 binaries under `~/.aspire/bin/` and `~/.aspire/dogfood/` are not touched by
 the cask in either direction; manage those with the steps above.
 
diff --git a/eng/clipack/Common.projitems b/eng/clipack/Common.projitems
index d9bfc4e9dab..049c8403def 100644
--- a/eng/clipack/Common.projitems
+++ b/eng/clipack/Common.projitems
@@ -42,12 +42,12 @@
   </Target>
 
   <!--
-    No install-route sidecar is staged into the per-RID CLI archive. The
-    shared archives are sidecar-free by contract; each route writes its own
+    No install-source sidecar is staged into the per-RID CLI archive. The
+    shared archives are sidecar-free by contract; each source writes its own
     .aspire-install.json at install time. The dotnet-tool nupkg is the
-    exception (route-exclusive, payload-embedded by
+    exception (source-exclusive, payload-embedded by
     src/Aspire.Cli/Aspire.Cli.csproj _PreparePreBuiltCliBinaryForPackTool).
-    See docs/specs/install-routes.md for the full authorship table.
+    See docs/specs/install-sources.md for the full authorship table.
 
     _AssertNoSidecarInArchiveStaging below is the build-time guard that
     fails the build if a regression starts staging the sidecar back in.
@@ -59,7 +59,7 @@
       <_ArchiveSidecarPath>$([MSBuild]::NormalizePath($(OutputPath), '.aspire-install.json'))</_ArchiveSidecarPath>
     </PropertyGroup>
     <Error Condition="Exists('$(_ArchiveSidecarPath)')"
-           Text="Per-RID CLI archives must not contain '.aspire-install.json' — shared across install routes. See docs/specs/install-routes.md. Found smuggled sidecar at $(_ArchiveSidecarPath)." />
+           Text="Per-RID CLI archives must not contain '.aspire-install.json' — shared across install sources. See docs/specs/install-sources.md. Found smuggled sidecar at $(_ArchiveSidecarPath)." />
   </Target>
 
   <Target Name="_PublishProject">
diff --git a/eng/scripts/get-aspire-cli-pr.ps1 b/eng/scripts/get-aspire-cli-pr.ps1
index 1394a1a6d02..82cdb3c6d3a 100755
--- a/eng/scripts/get-aspire-cli-pr.ps1
+++ b/eng/scripts/get-aspire-cli-pr.ps1
@@ -1539,11 +1539,11 @@ function Test-InstallerModeEnvironment {
     }
 }
 
-# Writes the PR-route install-source sidecar (.aspire-install.json) next to
+# Writes the PR-source install-source sidecar (.aspire-install.json) next to
 # the installed binary. Under -WhatIf, prints the target path and skips the
 # write so a real user's sidecar is never overwritten by a describe pass.
-# Authorship contract: docs/specs/install-routes.md.
-function Write-PRRouteSidecar {
+# Authorship contract: docs/specs/install-sources.md.
+function Write-PRSourceSidecar {
     [CmdletBinding(SupportsShouldProcess)]
     param(
         [Parameter(Mandatory = $true)]
@@ -1557,12 +1557,12 @@ function Write-PRRouteSidecar {
     $sidecarPath = Join-Path $sidecarDir '.aspire-install.json'
     $sidecarContent = "{""source"":""pr""}`n"
 
-    if ($PSCmdlet.ShouldProcess($sidecarPath, "Write route sidecar")) {
+    if ($PSCmdlet.ShouldProcess($sidecarPath, "Write source sidecar")) {
         [System.IO.Directory]::CreateDirectory($sidecarDir) | Out-Null
         [System.IO.File]::WriteAllText($sidecarPath, $sidecarContent)
     }
     else {
-        Write-Host "What if: Route sidecar would be written to: $sidecarPath"
+        Write-Host "What if: Source sidecar would be written to: $sidecarPath"
     }
 }
 
@@ -1701,8 +1701,8 @@ function Start-InstallFromLocalDir {
     Write-Message "Installing from local directory: $LocalDirPath" -Level Info
 
     # Set installation paths.
-    # PR-route installs are isolated under <prefix>/dogfood/pr-<N>/bin so they don't
-    # collide with the script-route prefix or with other PR installs. Hives remain shared
+    # PR-source installs are isolated under <prefix>/dogfood/pr-<N>/bin so they don't
+    # collide with the script-source prefix or with other PR installs. Hives remain shared
     # under <prefix>/hives/<label>/packages.
     $cliBinDir = if ($PRNumber -gt 0) {
         Join-Path (Join-Path (Join-Path $resolvedInstallPrefix "dogfood") "pr-$PRNumber") "bin"
@@ -1791,7 +1791,7 @@ function Start-InstallFromLocalDir {
     # PR installs from archives get a sidecar; --local-dir installs are unmanaged,
     # and dotnet-tool packages embed their own source=dotnet-tool sidecar.
     if (-not $HiveOnly -and $InstallMode -eq 'Archive' -and $PRNumber -gt 0) {
-        Write-PRRouteSidecar -InstallPrefix $resolvedInstallPrefix -PRNumber $PRNumber
+        Write-PRSourceSidecar -InstallPrefix $resolvedInstallPrefix -PRNumber $PRNumber
     }
 
     # Update PATH environment variables
@@ -1837,8 +1837,8 @@ function Start-DownloadAndInstall {
     Write-Message "Using workflow run https://github.com/$Script:Repository/actions/runs/$runId" -Level Info
 
     # Set installation paths.
-    # PR-route installs are isolated under <prefix>/dogfood/pr-<N>/bin so they don't
-    # collide with the script-route prefix or with other PR installs. Hives remain shared
+    # PR-source installs are isolated under <prefix>/dogfood/pr-<N>/bin so they don't
+    # collide with the script-source prefix or with other PR installs. Hives remain shared
     # under <prefix>/hives/<label>/packages.
     $cliBinDir = if ($PRNumber -gt 0) {
         Join-Path (Join-Path (Join-Path $resolvedInstallPrefix "dogfood") "pr-$PRNumber") "bin"
@@ -1927,7 +1927,7 @@ function Start-DownloadAndInstall {
     }
 
     if (-not $HiveOnly -and $InstallMode -eq 'Archive' -and $PRNumber -gt 0) {
-        Write-PRRouteSidecar -InstallPrefix $resolvedInstallPrefix -PRNumber $PRNumber
+        Write-PRSourceSidecar -InstallPrefix $resolvedInstallPrefix -PRNumber $PRNumber
     }
 
     # Update PATH environment variables
diff --git a/eng/scripts/get-aspire-cli-pr.sh b/eng/scripts/get-aspire-cli-pr.sh
index d7350ca3558..b1b004486b0 100755
--- a/eng/scripts/get-aspire-cli-pr.sh
+++ b/eng/scripts/get-aspire-cli-pr.sh
@@ -1436,7 +1436,7 @@ install_aspire_cli_from_binary() {
 
 # Computes the CLI install directory. PR installs are isolated under
 # <prefix>/dogfood/pr-<N>/bin; without PR_NUMBER, falls back to the shared
-# script-route bin dir.
+# script-source bin dir.
 compute_cli_install_dir() {
     if [[ -n "$PR_NUMBER" ]]; then
         printf '%s' "$INSTALL_PREFIX/dogfood/pr-$PR_NUMBER/bin"
@@ -1449,13 +1449,13 @@ compute_cli_install_dir() {
 # <install_prefix>/dogfood/pr-<N>/bin/.aspire-install.json. The sidecar marks
 # the install as PR-sourced so downstream consumers (e.g. 'aspire update')
 # know not to assume the stable script source. Per-RID archives produced
-# by eng/clipack are shared across routes and ship without a baked sidecar;
-# this write is the PR-route's authoritative author. If a future or
+# by eng/clipack are shared across sources and ship without a baked sidecar;
+# this write is the PR-source's authoritative author. If a future or
 # external archive ever smuggles a sidecar at the same path, this write
 # overwrites it by design. Under --dry-run the script is describe-but-do-
 # not-do: print the path it would write to and skip the filesystem mutation
 # so a real user's sidecar is never overwritten.
-write_pr_route_sidecar() {
+write_pr_source_sidecar() {
     local install_prefix="$1"
     local pr_number="$2"
 
@@ -1464,7 +1464,7 @@ write_pr_route_sidecar() {
     local sidecar_content='{"source":"pr"}'
 
     if [[ "$DRY_RUN" == true ]]; then
-        printf 'DRYRUN: would write route sidecar to: %s\n' "$sidecar_path"
+        printf 'DRYRUN: would write source sidecar to: %s\n' "$sidecar_path"
     else
         mkdir -p "$sidecar_dir"
         printf '%s\n' "$sidecar_content" > "$sidecar_path"
@@ -1513,8 +1513,8 @@ install_from_local_dir() {
 
     say_info "Installing from local directory: $local_dir"
 
-    # PR-route installs are isolated under <prefix>/dogfood/pr-<N>/bin so they
-    # don't collide with the script-route prefix or with other PR installs.
+    # PR-source installs are isolated under <prefix>/dogfood/pr-<N>/bin so they
+    # don't collide with the script-source prefix or with other PR installs.
     # Hives remain shared under <prefix>/hives/<label>/packages.
     local cli_install_dir
     cli_install_dir="$(compute_cli_install_dir)"
@@ -1620,7 +1620,7 @@ install_from_local_dir() {
     # PR installs from archives get a sidecar. --local-dir installs are unmanaged, and
     # dotnet-tool packages embed their own source=dotnet-tool sidecar.
     if [[ "$HIVE_ONLY" != true && "$INSTALL_MODE" == "archive" && -n "$PR_NUMBER" ]]; then
-        write_pr_route_sidecar "$INSTALL_PREFIX" "$PR_NUMBER"
+        write_pr_source_sidecar "$INSTALL_PREFIX" "$PR_NUMBER"
     fi
 
 }
@@ -1661,8 +1661,8 @@ download_and_install_from_pr() {
 
     say_info "Using workflow run https://github.com/${REPO}/actions/runs/$workflow_run_id"
 
-    # PR-route installs are isolated under <prefix>/dogfood/pr-<N>/bin so they
-    # don't collide with the script-route prefix or with other PR installs.
+    # PR-source installs are isolated under <prefix>/dogfood/pr-<N>/bin so they
+    # don't collide with the script-source prefix or with other PR installs.
     # Hives remain shared under <prefix>/hives/<label>/packages.
     local cli_install_dir
     cli_install_dir="$(compute_cli_install_dir)"
@@ -1781,10 +1781,10 @@ download_and_install_from_pr() {
         fi
     fi
 
-    # Write the PR-route sidecar only for installs from archives. Tool-mode packages
+    # Write the PR-source sidecar only for installs from archives. Tool-mode packages
     # carry their own source=dotnet-tool sidecar.
     if [[ "$HIVE_ONLY" != true && "$INSTALL_MODE" == "archive" && -n "$PR_NUMBER" ]]; then
-        write_pr_route_sidecar "$INSTALL_PREFIX" "$PR_NUMBER"
+        write_pr_source_sidecar "$INSTALL_PREFIX" "$PR_NUMBER"
     fi
 
 }
@@ -1856,8 +1856,8 @@ main() {
     fi
 
     # Set paths based on install prefix.
-    # PR-route installs go under $INSTALL_PREFIX/dogfood/pr-<N>/bin to isolate them from
-    # the script-route prefix and from other PR installs.
+    # PR-source installs go under $INSTALL_PREFIX/dogfood/pr-<N>/bin to isolate them from
+    # the script-source prefix and from other PR installs.
     if [[ -n "$PR_NUMBER" ]]; then
         cli_install_dir="$INSTALL_PREFIX/dogfood/pr-$PR_NUMBER/bin"
         INSTALL_PATH_UNEXPANDED="$INSTALL_PREFIX_UNEXPANDED/dogfood/pr-$PR_NUMBER/bin"
diff --git a/eng/scripts/get-aspire-cli.ps1 b/eng/scripts/get-aspire-cli.ps1
index a147298316e..f7e651c85ed 100755
--- a/eng/scripts/get-aspire-cli.ps1
+++ b/eng/scripts/get-aspire-cli.ps1
@@ -1180,16 +1180,16 @@ function Install-AspireCli {
             Write-Message "Aspire CLI successfully installed to: $cliPath" -Level Success
         }
 
-        # Write the script-route install-source sidecar next to the binary.
+        # Write the script-source install-source sidecar next to the binary.
         # Under -WhatIf, print the target path and skip the write.
-        # Authorship contract: docs/specs/install-routes.md.
+        # Authorship contract: docs/specs/install-sources.md.
         $sidecarPath = Join-Path $InstallPath '.aspire-install.json'
-        if ($PSCmdlet.ShouldProcess($sidecarPath, "Write route sidecar")) {
+        if ($PSCmdlet.ShouldProcess($sidecarPath, "Write source sidecar")) {
             [System.IO.Directory]::CreateDirectory($InstallPath) | Out-Null
             [System.IO.File]::WriteAllText($sidecarPath, "{""source"":""script""}`n")
         }
         else {
-            Write-Host "What if: Route sidecar would be written to: $sidecarPath"
+            Write-Host "What if: Source sidecar would be written to: $sidecarPath"
         }
 
         # Download and install VS Code extension if requested
diff --git a/eng/scripts/get-aspire-cli.sh b/eng/scripts/get-aspire-cli.sh
index ae83d63516a..9990067284a 100755
--- a/eng/scripts/get-aspire-cli.sh
+++ b/eng/scripts/get-aspire-cli.sh
@@ -1053,13 +1053,13 @@ main() {
         exit 1
     fi
 
-    # Write the script-route install-source sidecar next to the binary.
+    # Write the script-source install-source sidecar next to the binary.
     # Under --dry-run, print the target path and skip the write.
-    # Authorship contract: docs/specs/install-routes.md.
+    # Authorship contract: docs/specs/install-sources.md.
     local sidecar_path
     sidecar_path="$INSTALL_PATH/.aspire-install.json"
     if [[ "$DRY_RUN" == true ]]; then
-        printf 'DRYRUN: would write route sidecar to: %s\n' "$sidecar_path"
+        printf 'DRYRUN: would write source sidecar to: %s\n' "$sidecar_path"
     else
         mkdir -p "$INSTALL_PATH"
         printf '{"source":"script"}\n' > "$sidecar_path"
diff --git a/eng/scripts/verify-cli-archive.ps1 b/eng/scripts/verify-cli-archive.ps1
index 321e1cb555f..bf9a50fbffc 100644
--- a/eng/scripts/verify-cli-archive.ps1
+++ b/eng/scripts/verify-cli-archive.ps1
@@ -6,7 +6,7 @@
     This script:
     1. Cleans ~/.aspire to ensure no stale state
     2. Extracts the CLI archive to a temp location
-    3. Verifies the archive shape contains the native CLI payload and no install-route sidecar
+    3. Verifies the archive shape contains the native CLI payload and no install-source sidecar
     4. Runs 'aspire --version' to validate the binary executes
     5. Runs 'aspire new aspire-starter' to test C# starter creation
     6. Cleans up temp directories
@@ -96,8 +96,8 @@ function Get-ArchiveRoot {
 }
 
 function Test-ArchiveSidecar {
-    # Per-RID CLI archives must ship sidecar-free; each install route writes
-    # its own .aspire-install.json. See docs/specs/install-routes.md.
+    # Per-RID CLI archives must ship sidecar-free; each install source writes
+    # its own .aspire-install.json. See docs/specs/install-sources.md.
     param(
         [Parameter(Mandatory = $true)][string]$ExtractDir,
         [Parameter(Mandatory = $true)][string]$ArchiveFileName
@@ -112,9 +112,9 @@ function Test-ArchiveSidecar {
     $strays = Get-ChildItem -Path $ExtractDir -Recurse -File -Filter '.aspire-install.json' -Force -ErrorAction SilentlyContinue
     if ($strays) {
         $strayPaths = $strays | ForEach-Object { $_.FullName.Substring($ExtractDir.Length + 1).Replace('\', '/') }
-        throw "$ridFamily-* archive '$ArchiveFileName' must not contain '.aspire-install.json' (per-RID archives are shared across install routes; each route authors its own sidecar after extraction). Found: $($strayPaths -join ', ')"
+        throw "$ridFamily-* archive '$ArchiveFileName' must not contain '.aspire-install.json' (per-RID archives are shared across install sources; each source authors its own sidecar after extraction). Found: $($strayPaths -join ', ')"
     }
-    Write-Step "$ridFamily-* archive correctly omits the install-route sidecar."
+    Write-Step "$ridFamily-* archive correctly omits the install-source sidecar."
 }
 
 function Test-CSharpStarterProject {
diff --git a/eng/scripts/verify-cli-tool-nupkg.ps1 b/eng/scripts/verify-cli-tool-nupkg.ps1
index 05631987e78..dc5fd412074 100644
--- a/eng/scripts/verify-cli-tool-nupkg.ps1
+++ b/eng/scripts/verify-cli-tool-nupkg.ps1
@@ -226,7 +226,7 @@ try {
     }
 
     # The RID-specific tool nupkg is always installed via `dotnet tool install -g`.
-    # The sidecar's source must pin to 'dotnet-tool' so the CLI can route
+    # The sidecar's source must pin to 'dotnet-tool' so the CLI can source
     # `aspire update --self` to the correct delegating command. Other source
     # values would mis-identify the install and break self-update.
     if ([string]$sidecarJson.source -ne 'dotnet-tool') {
diff --git a/localhive.ps1 b/localhive.ps1
index bdea8c63a36..cd4ba8ec2fb 100644
--- a/localhive.ps1
+++ b/localhive.ps1
@@ -490,10 +490,10 @@ if (-not $SkipCli) {
       throw
     }
 
-    # Stamp the install-route sidecar so `aspire info` / `aspire uninstall`
+    # Stamp the install-source sidecar so install discovery
     # can identify this binary as a locally-built (`localhive`) install.
-    # The format matches docs/specs/install-routes.md exactly; localhive
-    # shares the script-route layout (binary under <prefix>/bin/, bundle
+    # The format matches docs/specs/install-sources.md exactly; localhive
+    # shares the script-source layout (binary under <prefix>/bin/, bundle
     # extracted at parent-of-bin).
     $sidecarPath = Join-Path $cliBinDir ".aspire-install.json"
     Set-Content -LiteralPath $sidecarPath -Value '{"source":"localhive"}' -Encoding UTF8 -NoNewline
@@ -526,9 +526,9 @@ if ($Archive) {
     # Compress-Archive. Compress-Archive enumerates inputs via the PowerShell
     # provider, which on non-Windows hosts treats files whose name starts with
     # '.' as hidden and excludes them from `<dir>/*` wildcard expansion. The
-    # portable layout includes bin/.aspire-install.json — the localhive route
-    # sidecar that `aspire doctor` and route-aware Aspire-home selection rely
-    # on (see docs/specs/install-routes.md) — and silently dropping it from
+    # portable layout includes bin/.aspire-install.json — the localhive source
+    # sidecar that install discovery and source-aware Aspire-home selection rely
+    # on (see docs/specs/install-sources.md) — and silently dropping it from
     # win-* zips built on Linux/macOS would produce sidecar-less installs on
     # the target machine. ZipFile walks the filesystem directly and includes
     # dotfiles unconditionally.
@@ -559,7 +559,7 @@ if ($Archive) {
         $zip.Dispose()
       }
       if (-not $hasSidecar) {
-        throw "Archive '$archivePath' is missing the install-route sidecar entry '$sidecarEntryName'. The zip creation path is dropping hidden files."
+        throw "Archive '$archivePath' is missing the install-source sidecar entry '$sidecarEntryName'. The zip creation path is dropping hidden files."
       }
     }
   } else {
diff --git a/localhive.sh b/localhive.sh
index 7f0dcff390c..ff8b5faa3f6 100755
--- a/localhive.sh
+++ b/localhive.sh
@@ -466,10 +466,10 @@ if [[ $SKIP_CLI -eq 0 ]]; then
       exit 1
     fi
 
-    # Stamp the install-route sidecar so `aspire info` / `aspire uninstall`
+    # Stamp the install-source sidecar so install discovery
     # can identify this binary as a locally-built (`localhive`) install.
-    # The format matches docs/specs/install-routes.md exactly; localhive
-    # shares the script-route layout (binary under <prefix>/bin/, bundle
+    # The format matches docs/specs/install-sources.md exactly; localhive
+    # shares the script-source layout (binary under <prefix>/bin/, bundle
     # extracted at parent-of-bin).
     printf '%s' '{"source":"localhive"}' > "$CLI_BIN_DIR/.aspire-install.json"
 
diff --git a/src/Aspire.Cli/Acquisition/IInstallSidecarReader.cs b/src/Aspire.Cli/Acquisition/IInstallSidecarReader.cs
index 17f03aa5b43..98b6bea4012 100644
--- a/src/Aspire.Cli/Acquisition/IInstallSidecarReader.cs
+++ b/src/Aspire.Cli/Acquisition/IInstallSidecarReader.cs
@@ -4,7 +4,7 @@
 namespace Aspire.Cli.Acquisition;
 
 /// <summary>
-/// Result of reading an install-route sidecar from a binary directory.
+/// Result of reading an install-source sidecar from a binary directory.
 /// </summary>
 /// <param name="SidecarPath">
 /// Absolute path of the sidecar file that was read. Always populated for
@@ -12,8 +12,8 @@ namespace Aspire.Cli.Acquisition;
 /// resolved sidecar path.
 /// </param>
 /// <param name="Source">
-/// Parsed install route. <see cref="InstallSource.Unknown"/> when the sidecar
-/// exists but its <c>source</c> field does not match a known route.
+/// Parsed install source. <see cref="InstallSource.Unknown"/> when the sidecar
+/// exists but its <c>source</c> field does not match a known source.
 /// </param>
 /// <param name="RawSource">
 /// The literal <c>source</c> string from the sidecar (may be a value not yet
@@ -23,7 +23,7 @@ namespace Aspire.Cli.Acquisition;
 internal sealed record InstallSidecarInfo(string SidecarPath, InstallSource Source, string RawSource);
 
 /// <summary>
-/// Result of attempting to read an install-route sidecar.
+/// Result of attempting to read an install-source sidecar.
 /// </summary>
 /// <param name="SidecarPath">
 /// Path of the sidecar file that was considered. Absolute when the binary
@@ -46,14 +46,13 @@ public sealed record Invalid(string Path, string Reason) : InstallSidecarReadRes
 }
 
 /// <summary>
-/// Reads the install-route sidecar (<c>.aspire-install.json</c>) that an
-/// install route writes next to the CLI binary. The sidecar identifies the
-/// installation route so callers (e.g. <c>BundleService</c>,
-/// <c>aspire doctor</c>, <c>aspire uninstall</c>) can branch behavior without
-/// path-shape heuristics.
+/// Reads the install-source sidecar (<c>.aspire-install.json</c>) that an
+/// install source writes next to the CLI binary. The sidecar identifies the
+/// installation source so callers (e.g. <c>BundleService</c>,
+/// <c>aspire --info</c>) can branch behavior without path-shape heuristics.
 /// </summary>
 /// <remarks>
-/// See <c>docs/specs/install-routes.md</c> for the file contract. The reader
+/// See <c>docs/specs/install-sources.md</c> for the file contract. The reader
 /// is AOT-safe: parsing uses <c>JsonDocument</c> instead of reflection-based
 /// deserialization.
 /// </remarks>
diff --git a/src/Aspire.Cli/Acquisition/IInstallationDiscovery.cs b/src/Aspire.Cli/Acquisition/IInstallationDiscovery.cs
index 99e86a18295..eea627ff8c8 100644
--- a/src/Aspire.Cli/Acquisition/IInstallationDiscovery.cs
+++ b/src/Aspire.Cli/Acquisition/IInstallationDiscovery.cs
@@ -4,7 +4,7 @@
 namespace Aspire.Cli.Acquisition;
 
 /// <summary>
-/// Discovers Aspire CLI installations on this machine for <c>aspire doctor</c>.
+/// Discovers Aspire CLI installations on this machine for <c>aspire --info</c>.
 /// </summary>
 /// <remarks>
 /// Two modes:
@@ -12,13 +12,13 @@ namespace Aspire.Cli.Acquisition;
 ///   <item>
 ///     <description><see cref="DescribeSelf"/> — cheap path that describes
 ///     only the currently running CLI. No process spawning, no filesystem
-///     walks. Used by the hidden <c>aspire doctor --self</c> peer-probe path.</description>
+///     walks. Used by the hidden <c>aspire --info --self</c> peer-probe path.</description>
 ///   </item>
 ///   <item>
 ///     <description><see cref="DiscoverAllAsync"/> — walks <c>$PATH</c> plus
 ///     well-known install prefixes and asks each peer with required install
-///     metadata to self-describe via a child <c>aspire doctor --self --format json</c>
-///     call. Used by the default <c>aspire doctor</c> path.</description>
+///     metadata to self-describe via a child <c>aspire --info --self --format json</c>
+///     call. Used by <c>aspire --info</c>.</description>
 ///   </item>
 /// </list>
 /// </remarks>
@@ -27,7 +27,7 @@ internal interface IInstallationDiscovery
     /// <summary>
     /// Describes the currently running CLI. The result always has
     /// <see cref="InstallationInfo.Status"/> = <c>ok</c> with version /
-    /// channel / route populated from in-process readers.
+    /// channel / source populated from in-process readers.
     /// </summary>
     InstallationInfo DescribeSelf();
 
diff --git a/src/Aspire.Cli/Acquisition/IPeerInstallProbe.cs b/src/Aspire.Cli/Acquisition/IPeerInstallProbe.cs
index 4f851472f41..d04b3080d79 100644
--- a/src/Aspire.Cli/Acquisition/IPeerInstallProbe.cs
+++ b/src/Aspire.Cli/Acquisition/IPeerInstallProbe.cs
@@ -5,7 +5,7 @@ namespace Aspire.Cli.Acquisition;
 
 /// <summary>
 /// Result of asking a peer Aspire CLI binary to self-describe via
-/// <c>&lt;peer&gt; doctor --self --format json</c>.
+/// <c>&lt;peer&gt; --info --self --format json</c>.
 /// </summary>
 internal abstract record PeerProbeResult
 {
@@ -20,12 +20,12 @@ public sealed record Failed(string Reason) : PeerProbeResult;
 /// Spawns a peer Aspire CLI binary to ask it to describe itself.
 /// Implementations MUST enforce a process-wide timeout, a stdout byte cap,
 /// and kill the entire process tree on timeout so a hung or runaway peer
-/// can't survive past <c>aspire doctor</c>'s lifetime.
+/// can't survive past <c>aspire --info</c>'s lifetime.
 /// </summary>
 internal interface IPeerInstallProbe
 {
     /// <summary>
-    /// Runs <c><paramref name="binaryPath"/> doctor --self --format json</c> and
+    /// Runs <c><paramref name="binaryPath"/> --info --self --format json</c> and
     /// returns either the parsed <see cref="InstallationInfo"/> or a failure
     /// reason. <c>--self</c> bounds the peer to describing only itself so the
     /// probe does not recursively trigger a discovery walk inside the peer.
diff --git a/src/Aspire.Cli/Acquisition/InstallSidecarReader.cs b/src/Aspire.Cli/Acquisition/InstallSidecarReader.cs
index 990c747f996..ead38ec0eee 100644
--- a/src/Aspire.Cli/Acquisition/InstallSidecarReader.cs
+++ b/src/Aspire.Cli/Acquisition/InstallSidecarReader.cs
@@ -24,9 +24,9 @@ public InstallSidecarReader(ILogger<InstallSidecarReader>? logger = null)
     }
 
     /// <summary>
-    /// Well-known file name of the sidecar that each install route writes
+    /// Well-known file name of the sidecar that each install source writes
     /// next to the CLI binary. Matches the contract in
-    /// <c>docs/specs/install-routes.md</c>.
+    /// <c>docs/specs/install-sources.md</c>.
     /// </summary>
     public const string SidecarFileName = ".aspire-install.json";
 
diff --git a/src/Aspire.Cli/Acquisition/InstallSource.cs b/src/Aspire.Cli/Acquisition/InstallSource.cs
index f6f10830b53..605c8306acd 100644
--- a/src/Aspire.Cli/Acquisition/InstallSource.cs
+++ b/src/Aspire.Cli/Acquisition/InstallSource.cs
@@ -4,16 +4,16 @@
 namespace Aspire.Cli.Acquisition;
 
 /// <summary>
-/// Identifies the installation route that placed the running CLI binary.
+/// Identifies the installation source that placed the running CLI binary.
 /// The value is read from the <c>source</c> field of the
 /// <c>.aspire-install.json</c> sidecar that sits next to the binary.
-/// See <c>docs/specs/install-routes.md</c>.
+/// See <c>docs/specs/install-sources.md</c>.
 /// </summary>
 internal enum InstallSource
 {
     /// <summary>
     /// No sidecar was found, or the sidecar contained a value that does not
-    /// match any known route. Treated as legacy / pre-sidecar by callers.
+    /// match any known source. Treated as legacy / pre-sidecar by callers.
     /// </summary>
     Unknown = 0,
 
@@ -27,7 +27,7 @@ internal enum InstallSource
     Winget,
 
     /// <summary>Homebrew cask.</summary>
-    Brew,
+    Homebrew,
 
     /// <summary>.NET global tool (<c>dotnet tool install -g Aspire.Cli</c>).</summary>
     DotnetTool,
@@ -42,7 +42,7 @@ internal enum InstallSource
 /// </summary>
 internal static class InstallSourceExtensions
 {
-    // Wire strings — these match the contract in docs/specs/install-routes.md
+    // Wire strings — these match the contract in docs/specs/install-sources.md
     // exactly. They are kebab-case strings consumed by both the installer
     // scripts and BundleService.ComputeDefaultExtractDir.
     internal const string ScriptWire = "script";
@@ -65,7 +65,7 @@ public static InstallSource ParseInstallSource(string? raw)
             ScriptWire => InstallSource.Script,
             PrWire => InstallSource.Pr,
             WingetWire => InstallSource.Winget,
-            BrewWire => InstallSource.Brew,
+            BrewWire => InstallSource.Homebrew,
             DotnetToolWire => InstallSource.DotnetTool,
             LocalHiveWire => InstallSource.LocalHive,
             _ => InstallSource.Unknown,
@@ -84,7 +84,7 @@ public static InstallSource ParseInstallSource(string? raw)
             InstallSource.Script => ScriptWire,
             InstallSource.Pr => PrWire,
             InstallSource.Winget => WingetWire,
-            InstallSource.Brew => BrewWire,
+            InstallSource.Homebrew => BrewWire,
             InstallSource.DotnetTool => DotnetToolWire,
             InstallSource.LocalHive => LocalHiveWire,
             _ => null,
diff --git a/src/Aspire.Cli/Acquisition/InstallationCandidateSources.cs b/src/Aspire.Cli/Acquisition/InstallationCandidateSources.cs
index d9a573a778b..191ba990ac3 100644
--- a/src/Aspire.Cli/Acquisition/InstallationCandidateSources.cs
+++ b/src/Aspire.Cli/Acquisition/InstallationCandidateSources.cs
@@ -130,7 +130,7 @@ internal sealed class DotnetToolStoreInstallationCandidateSource : IInstallation
     // Reparse points (symlinks / junctions) are skipped so a symlink cycle anywhere
     // under the store cannot make `Directory.EnumerateFiles` walk indefinitely. The
     // legitimate tool-store layout contains no symlinks, so this loses nothing real
-    // and removes a self-DoS surface from `aspire doctor` discovery.
+    // and removes a self-DoS surface from `aspire --info` discovery.
     private static readonly EnumerationOptions s_enumerationOptions = new()
     {
         RecurseSubdirectories = true,
diff --git a/src/Aspire.Cli/Acquisition/InstallationDiscovery.cs b/src/Aspire.Cli/Acquisition/InstallationDiscovery.cs
index 49f2f6cca3e..9f961e904ef 100644
--- a/src/Aspire.Cli/Acquisition/InstallationDiscovery.cs
+++ b/src/Aspire.Cli/Acquisition/InstallationDiscovery.cs
@@ -11,7 +11,7 @@ namespace Aspire.Cli.Acquisition;
 /// Default <see cref="IInstallationDiscovery"/>. The self-describe path
 /// composes data already available in-process (channel from
 /// <see cref="IIdentityChannelReader"/>, version from
-/// <see cref="VersionHelper.GetDefaultTemplateVersion"/>, route from the
+/// <see cref="VersionHelper.GetDefaultTemplateVersion"/>, source from the
 /// running binary's sidecar) so it is cheap and side-effect-free.
 /// </summary>
 /// <remarks>
@@ -78,10 +78,10 @@ private InstallationInfo DescribeSelf(string? processPath, IReadOnlyList<Install
         // Use the wire string from the parsed source so callers see the same
         // identifier the install scripts wrote, not the C# enum name. For
         // sidecars with an unrecognized source value we surface the raw
-        // string so users see "(unknown: future-route)" rather than nothing.
-        // Route through the shared helper so an empty RawSource collapses to
+        // string so users see "(unknown: future-source)" rather than nothing.
+        // Funnel through the shared helper so an empty RawSource collapses to
         // null and the JSON shape of `--self` matches the full discovery walk.
-        var route = sidecar is not null ? GetRouteFromSidecar(sidecar) : null;
+        var source = sidecar is not null ? GetSourceFromSidecar(sidecar) : null;
 
         return new InstallationInfo
         {
@@ -95,7 +95,7 @@ private InstallationInfo DescribeSelf(string? processPath, IReadOnlyList<Install
             CanonicalPath = canonicalPath,
             Version = VersionHelper.GetDefaultTemplateVersion(),
             Channel = TryReadChannel(),
-            Route = route,
+            Source = source,
             PathStatus = pathStatus,
             Status = InstallationInfoStatus.Ok,
         };
@@ -218,10 +218,10 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
             {
                 case PeerProbeResult.Ok ok:
                     // Preserve the original discovered path for display and
-                    // canonical path for identity. Overlay the route from
+                    // canonical path for identity. Overlay the source from
                     // the LOCAL sidecar so older peers using the
-                    // --version fallback (which can't report route) still
-                    // surface the install route we already know about.
+                    // --version fallback (which can't report source) still
+                    // surface the install source we already know about.
                     // Also derive the channel for PR builds — the channel
                     // is structurally `pr-<N>` for a PR install, and we
                     // can recover it from the install path layout
@@ -229,7 +229,7 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
                     // version string (<x.y.z>-pr.<N>.<hash>) baked at
                     // build time, so we surface it even when the peer
                     // didn't report it.
-                    var route = ok.Info.Route ?? GetRouteFromSidecar(sidecar);
+                    var source = ok.Info.Source ?? GetSourceFromSidecar(sidecar);
                     var channel = ok.Info.Channel;
                     if (string.IsNullOrEmpty(channel) && sidecar.Source == InstallSource.Pr)
                     {
@@ -240,7 +240,7 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
                         // Final attempt: derive the channel from the peer's
                         // reported version. This is the only signal we have
                         // for older peers that don't recognize the
-                        // `doctor --self` self-describe contract — they
+                        // `--info --self` self-describe contract — they
                         // fall through to the `--version` floor in the
                         // probe and can't report their channel directly,
                         // but the assembly's InformationalVersion has it
@@ -252,20 +252,20 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
                     {
                         Path = candidate.BinaryPath,
                         CanonicalPath = canonical,
-                        Route = route,
+                        Source = source,
                         Channel = channel,
                         PathStatus = pathStatus,
                     });
                     break;
                 case PeerProbeResult.Failed failed:
                     _logger.LogDebug(
-                        "Discovery: candidate '{Canonical}' (origin: {Origin}, route: {Route}) failed peer probe: {Reason}.",
-                        canonical, candidate.Origin, GetRouteFromSidecar(sidecar), failed.Reason);
+                        "Discovery: candidate '{Canonical}' (origin: {Origin}, source: {Source}) failed peer probe: {Reason}.",
+                        canonical, candidate.Origin, GetSourceFromSidecar(sidecar), failed.Reason);
                     results.Add(new InstallationInfo
                     {
                         Path = candidate.BinaryPath,
                         CanonicalPath = canonical,
-                        Route = GetRouteFromSidecar(sidecar),
+                        Source = GetSourceFromSidecar(sidecar),
                         PathStatus = pathStatus,
                         Status = InstallationInfoStatus.Failed,
                         StatusReason = failed.Reason,
@@ -284,7 +284,7 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
     }
 
     /// <summary>
-    /// Derives the <c>pr-&lt;N&gt;</c> identity channel for a PR-route install
+    /// Derives the <c>pr-&lt;N&gt;</c> identity channel for a PR-source install
     /// from its on-disk path. The PR install layout is, by convention,
     /// <c>&lt;root&gt;/dogfood/pr-&lt;N&gt;/bin/aspire</c> (or with a
     /// <c>.exe</c>); this method walks up two directories from the binary
@@ -360,10 +360,10 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
     /// Like <see cref="TryDerivePrChannel(string)"/>, this is a purely
     /// cosmetic enrichment for the user-facing table. It rescues the
     /// channel column for peers that don't recognize the
-    /// <c>doctor --self</c> self-describe contract: those fall through to
+    /// <c>--info --self</c> self-describe contract: those fall through to
     /// the <c>--version</c> floor in the probe and can't report their
     /// channel directly, but their assembly's InformationalVersion has
-    /// the PR number baked in regardless of route.
+    /// the PR number baked in regardless of source.
     /// </remarks>
     internal static string? TryDerivePrChannelFromVersion(string? version)
     {
@@ -402,9 +402,9 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
         }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
-            // Same defensive posture as doctor: a misconfigured dev build
+            // Same defensive posture as discovery: a misconfigured dev build
             // with no AspireCliChannel assembly metadata must not break
-            // aspire doctor.
+            // `aspire --info`.
             _logger.LogDebug(ex, "Could not read identity channel for InstallationDiscovery.");
             return null;
         }
@@ -413,12 +413,12 @@ internal async Task<IReadOnlyList<InstallationInfo>> DiscoverAllAsync(string? pr
     private static string GetNotProbedReason(InstallSidecarReadResult result)
         => result switch
         {
-            InstallSidecarReadResult.NotFound => $"No install-route sidecar found at {result.SidecarPath}; peer was not probed.",
-            InstallSidecarReadResult.Invalid => $"Install-route sidecar at {result.SidecarPath} could not be read or parsed; peer was not probed.",
-            _ => $"No install-route sidecar found at {result.SidecarPath}; peer was not probed.",
+            InstallSidecarReadResult.NotFound => $"No install-source sidecar found at {result.SidecarPath}; peer was not probed.",
+            InstallSidecarReadResult.Invalid => $"Install-source sidecar at {result.SidecarPath} could not be read or parsed; peer was not probed.",
+            _ => $"No install-source sidecar found at {result.SidecarPath}; peer was not probed.",
         };
 
-    private static string? GetRouteFromSidecar(InstallSidecarInfo sidecar)
+    private static string? GetSourceFromSidecar(InstallSidecarInfo sidecar)
         => sidecar.Source.ToWireString() ?? (string.IsNullOrEmpty(sidecar.RawSource) ? null : sidecar.RawSource);
 
     /// <summary>
diff --git a/src/Aspire.Cli/Acquisition/InstallationInfo.cs b/src/Aspire.Cli/Acquisition/InstallationInfo.cs
index ad021bf0771..cce0d98c3ee 100644
--- a/src/Aspire.Cli/Acquisition/InstallationInfo.cs
+++ b/src/Aspire.Cli/Acquisition/InstallationInfo.cs
@@ -8,13 +8,13 @@ namespace Aspire.Cli.Acquisition;
 
 /// <summary>
 /// Describes one Aspire CLI installation, as surfaced by
-/// <c>aspire doctor --format json</c>. Each entry corresponds to a single
+/// <c>aspire --info --format json</c>. Each entry corresponds to a single
 /// binary either running this process or discovered on the system.
 /// </summary>
 /// <remarks>
 /// <para>
-/// The JSON shape is part of the <c>installations</c> property in the
-/// <c>aspire doctor --format json</c> contract. Fields use camelCase wire names via
+/// The JSON shape is part of the <c>aspire --info --self --format json</c> and
+/// <c>aspire --info --format json</c> contracts. Fields use camelCase wire names via
 /// <see cref="JsonPropertyNameAttribute"/> applied explicitly here so the
 /// schema stays decoupled from the project-wide camelCase policy: another
 /// process may parse this output across CLI versions and we don't want to
@@ -64,14 +64,14 @@ internal sealed record InstallationInfo
     public string? Channel { get; init; }
 
     /// <summary>
-    /// Install route as recorded by the route's own sidecar
+    /// Install source as recorded by the source's own sidecar
     /// (<c>.aspire-install.json</c>). Wire string from
     /// <see cref="InstallSourceExtensions.ToWireString"/>. May be
     /// <see langword="null"/> for PATH discoveries whose install metadata
     /// sidecar is missing or invalid — see <see cref="Status"/>.
     /// </summary>
-    [JsonPropertyName("route")]
-    public string? Route { get; init; }
+    [JsonPropertyName("source")]
+    public string? Source { get; init; }
 
     /// <summary>
     /// Relationship between this binary and the user's <c>$PATH</c>.
@@ -131,7 +131,7 @@ internal static class InstallationPathStatus
 }
 
 /// <summary>
-/// Parses rows from the doctor installation discovery wire contract.
+/// Parses rows from the install discovery wire contract.
 /// </summary>
 internal static class InstallationInfoParser
 {
@@ -161,7 +161,7 @@ string GetStringOr(string property, string fallback)
             CanonicalPath = GetOptionalString("canonicalPath"),
             Version = GetOptionalString("version"),
             Channel = GetOptionalString("channel"),
-            Route = GetOptionalString("route"),
+            Source = GetOptionalString("source"),
             PathStatus = pathStatus,
             Status = GetStringOr("status", InstallationInfoStatus.Ok),
             StatusReason = GetOptionalString("statusReason"),
diff --git a/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs b/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs
index e8a91cdf270..3be324babc1 100644
--- a/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs
+++ b/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs
@@ -8,8 +8,8 @@ namespace Aspire.Cli.Acquisition;
 
 /// <summary>
 /// First-run self-stamp for winget-installed CLI binaries. Writes the
-/// install-route sidecar when the OS reports the running binary as a winget
-/// portable install. See <c>docs/specs/install-routes.md</c>.
+/// install-source sidecar when the OS reports the running binary as a winget
+/// portable install. See <c>docs/specs/install-sources.md</c>.
 /// </summary>
 internal sealed class WingetFirstRunProbe
 {
diff --git a/src/Aspire.Cli/Commands/SetupCommand.cs b/src/Aspire.Cli/Commands/SetupCommand.cs
index abdfa442a2a..f0014358ad0 100644
--- a/src/Aspire.Cli/Commands/SetupCommand.cs
+++ b/src/Aspire.Cli/Commands/SetupCommand.cs
@@ -57,9 +57,9 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
             return CommandResult.Failure(CliExitCodes.FailedToBuildArtifacts, "Could not determine the CLI executable path.");
         }
 
-        // `aspire setup` uses a route-independent default (parent of the binary's dir).
-        // Do not switch to `_bundleService.GetDefaultExtractDir` — that path is route-aware
-        // and reserved for auto-extract, where managed-route layouts must stay package-owned.
+        // `aspire setup` uses a source-independent default (parent of the binary's dir).
+        // Do not switch to `_bundleService.GetDefaultExtractDir` — that path is source-aware
+        // and reserved for auto-extract, where managed-source layouts must stay package-owned.
         if (string.IsNullOrEmpty(installPath))
         {
             installPath = GetDefaultInstallPath(processPath);
@@ -103,7 +103,7 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
 
     /// <summary>
     /// Returns the parent of <paramref name="processPath"/>'s directory, or <c>null</c> if
-    /// none. Route-independent counterpart to the route-aware <see cref="IBundleService.GetDefaultExtractDir"/>.
+    /// none. Source-independent counterpart to the source-aware <see cref="IBundleService.GetDefaultExtractDir"/>.
     /// </summary>
     internal static string? GetDefaultInstallPath(string? processPath)
     {
diff --git a/src/Aspire.Cli/Utils/CliPathHelper.cs b/src/Aspire.Cli/Utils/CliPathHelper.cs
index 1548d5b39ce..2947c62a226 100644
--- a/src/Aspire.Cli/Utils/CliPathHelper.cs
+++ b/src/Aspire.Cli/Utils/CliPathHelper.cs
@@ -15,7 +15,7 @@ internal static string GetAspireHomeDirectory(string? processPath = null, ILogge
     {
         var effectiveProcessPath = processPath ?? Environment.ProcessPath;
 
-        return TryGetAspireHomeDirectoryFromInstallRoute(effectiveProcessPath, logger)
+        return TryGetAspireHomeDirectoryFromInstallSource(effectiveProcessPath, logger)
             ?? GetDefaultAspireHomeDirectory();
     }
 
@@ -31,7 +31,7 @@ internal static string GetDefaultAspireHomeDirectory(string? configuredAspireHom
             : configuredAspireHome;
     }
 
-    internal static string? TryGetAspireHomeDirectoryFromInstallRoute(string? processPath, ILogger? logger = null)
+    internal static string? TryGetAspireHomeDirectoryFromInstallSource(string? processPath, ILogger? logger = null)
     {
         if (string.IsNullOrEmpty(processPath))
         {
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/Common/FakeArchiveHelper.cs b/tests/Aspire.Acquisition.Tests/Scripts/Common/FakeArchiveHelper.cs
index 9d571c4238f..5ccdbc2414b 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/Common/FakeArchiveHelper.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/Common/FakeArchiveHelper.cs
@@ -84,7 +84,7 @@ public static async Task<FakeArchive> CreateFakeArchiveWithBadChecksumAsync(stri
     /// </summary>
     /// <param name="includeStraySidecar">When true, adds a <c>.aspire-install.json</c>
     /// at the archive root so the verifier's sidecar-rejection contract can be
-    /// asserted; see <c>docs/specs/install-routes.md</c>.</param>
+    /// asserted; see <c>docs/specs/install-sources.md</c>.</param>
     /// <param name="nestAspireUnderSubdir">When true, places the <c>aspire</c> binary
     /// under a single subdirectory inside the archive rather than at the root. This
     /// exercises <c>Get-ArchiveRoot</c>'s single-subdirectory branch and confirms the
@@ -119,7 +119,7 @@ public static async Task<FakeArchive> CreateFakeVerifyArchiveAsync(
 
             if (includeStraySidecar)
             {
-                // Per docs/specs/install-routes.md, per-RID archives must ship
+                // Per docs/specs/install-sources.md, per-RID archives must ship
                 // sidecar-free. The verifier rejects archives that contain a
                 // .aspire-install.json at the archive root.
                 var sidecarPath = Path.Combine(contentDir, ".aspire-install.json");
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/LocalHiveScriptFunctionTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/LocalHiveScriptFunctionTests.cs
index 2d6c59b8878..3e13b9c2fc0 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/LocalHiveScriptFunctionTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/LocalHiveScriptFunctionTests.cs
@@ -72,12 +72,22 @@ public void Source_DoesNotWriteGlobalChannel(string scriptPathName)
         Assert.DoesNotContain("aspire config set", source, StringComparison.OrdinalIgnoreCase);
     }
 
+    [Theory]
+    [InlineData(nameof(ScriptPaths.LocalHiveShell))]
+    [InlineData(nameof(ScriptPaths.LocalHivePowerShell))]
+    public void Source_DoesNotReferenceInfoCommand(string scriptPathName)
+    {
+        var source = File.ReadAllText(GetRepoPath(GetScriptPath(scriptPathName)));
+
+        Assert.DoesNotContain("aspire info", source, StringComparison.OrdinalIgnoreCase);
+    }
+
     [Fact]
     public void PowerShellSource_WindowsArchivePathDoesNotUseCompressArchive()
     {
         // Compress-Archive enumerates inputs via the PowerShell provider, which on
         // non-Windows hosts hides dotfiles from `<dir>/*` wildcard expansion. The
-        // portable layout includes bin/.aspire-install.json — the localhive route
+        // portable layout includes bin/.aspire-install.json — the localhive source
         // sidecar — and silently dropping it from a win-* zip built on Linux/macOS
         // would produce sidecar-less installs on the target. Use
         // [System.IO.Compression.ZipFile]::CreateFromDirectory instead.
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallE2ETests.cs b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallE2ETests.cs
index b69318b4d85..29ef9822a74 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallE2ETests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallE2ETests.cs
@@ -20,7 +20,7 @@ public class PRScriptInstallE2ETests(ITestOutputHelper testOutput)
     private readonly ITestOutputHelper _testOutput = testOutput;
 
     [Fact]
-    public async Task PRScript_InstallsCliAndWritesRouteSidecar()
+    public async Task PRScript_InstallsCliAndWritesSourceSidecar()
     {
         using var env = new TestEnvironment();
         var cancellationToken = TestContext.Current.CancellationToken;
@@ -57,7 +57,7 @@ public async Task PRScript_InstallsCliAndWritesRouteSidecar()
         Assert.True(File.Exists(Path.Combine(binDir, "aspire")), $"CLI binary missing under {binDir}");
 
         var sidecarPath = Path.Combine(binDir, ".aspire-install.json");
-        Assert.True(File.Exists(sidecarPath), $"Route sidecar missing at {sidecarPath}");
+        Assert.True(File.Exists(sidecarPath), $"Source sidecar missing at {sidecarPath}");
 
         var sidecarContent = await File.ReadAllTextAsync(sidecarPath, cancellationToken);
         _testOutput.WriteLine($"Sidecar content after install: {sidecarContent}");
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallerModeTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallerModeTests.cs
index 4741ada81bf..01a96c191b3 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallerModeTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptInstallerModeTests.cs
@@ -170,7 +170,7 @@ exit 0
                 ;;
             esac
 
-            echo "unexpected brew command: $*" >&2
+            echo "unexpected Homebrew command: $*" >&2
             exit 1
             """);
         FileHelper.MakeExecutable(brewPath);
@@ -471,7 +471,7 @@ public async Task Bash_WinGetMode_PrDryRun_DownloadsManifestAndNativeArchives()
         Assert.Contains("-Force", result.Output);
         Assert.Contains("built-nugets", result.Output);
         Assert.DoesNotContain("Add to your shell profile", result.Output);
-        Assert.DoesNotContain("route sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("source sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("dogfood/pr-12345/bin", result.Output);
     }
 
@@ -496,7 +496,7 @@ public async Task Bash_HomebrewMode_PrDryRun_DownloadsCaskAndNativeArchives()
         Assert.Contains("--archive-root", result.Output);
         Assert.Contains("built-nugets", result.Output);
         Assert.DoesNotContain("Add to your shell profile", result.Output);
-        Assert.DoesNotContain("route sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("source sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("dogfood/pr-12345/bin", result.Output);
     }
 
@@ -634,7 +634,7 @@ public async Task PowerShell_WinGetMode_WhatIf_DownloadsManifestAndNativeArchive
         Assert.Contains("-Force", result.Output);
         Assert.Contains("built-nugets", result.Output);
         Assert.DoesNotContain("Add to your shell profile", result.Output);
-        Assert.DoesNotContain("Route sidecar", result.Output);
+        Assert.DoesNotContain("Source sidecar", result.Output);
         Assert.DoesNotContain($"dogfood{Path.DirectorySeparatorChar}pr-12345{Path.DirectorySeparatorChar}bin", result.Output);
     }
 
@@ -659,7 +659,7 @@ public async Task PowerShell_HomebrewMode_WhatIf_DownloadsCaskAndNativeArchives(
         Assert.Contains("--archive-root", result.Output);
         Assert.Contains("built-nugets", result.Output);
         Assert.DoesNotContain("Add to your shell profile", result.Output);
-        Assert.DoesNotContain("Route sidecar", result.Output);
+        Assert.DoesNotContain("Source sidecar", result.Output);
         Assert.DoesNotContain($"dogfood{Path.DirectorySeparatorChar}pr-12345{Path.DirectorySeparatorChar}bin", result.Output);
     }
 
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptPowerShellTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptPowerShellTests.cs
index 769f442d673..59da52d6f2d 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptPowerShellTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptPowerShellTests.cs
@@ -435,14 +435,14 @@ public async Task LocalDir_WhatIf_WithGitHubRunIdEnvSet_UsesLocalHiveLabel()
         Assert.DoesNotContain("run-99999", result.Output, StringComparison.OrdinalIgnoreCase);
     }
 
-    // PR-route CLI binary lands at <prefix>/dogfood/pr-<N>/bin so PR installs
-    // do not collide with the script-route prefix or with other PR installs.
+    // PR-source CLI binary lands at <prefix>/dogfood/pr-<N>/bin so PR installs
+    // do not collide with the script-source prefix or with other PR installs.
     // Under -WhatIf the script emits the absolute install path via a
     // "What if: Aspire CLI binary would be installed to: <path>" message on stdout
     // (PS-native WhatIf style); this test parses that message to verify the
     // resolved install path.
     [Fact]
-    public async Task WhatIf_PRRoute_CliInstallPath_IsUnderDogfoodPrN()
+    public async Task WhatIf_PRSource_CliInstallPath_IsUnderDogfoodPrN()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -455,14 +455,14 @@ public async Task WhatIf_PRRoute_CliInstallPath_IsUnderDogfoodPrN()
         Assert.Contains($"What if: Aspire CLI binary would be installed to: {expectedBinaryPath}", result.Output);
     }
 
-    // Under -WhatIf the PR-route script must NOT write the source=pr sidecar
+    // Under -WhatIf the PR-source script must NOT write the source=pr sidecar
     // at <prefix>/dogfood/pr-<N>/.aspire-install.json. The describe-but-do-not-do
     // contract requires the script to print a "What if:" message naming the path
     // it would write, then return without touching the filesystem. Positive
-    // sidecar content (the source field) for the PR route is covered by
+    // sidecar content (the source field) for the PR source is covered by
     // end-to-end install runs, not at this unit-test layer.
     [Fact]
-    public async Task WhatIf_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath()
+    public async Task WhatIf_PRSource_DoesNotWriteSidecar_AndAnnouncesPath()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -472,13 +472,13 @@ public async Task WhatIf_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "dogfood", "pr-99999", "bin", ".aspire-install.json");
-        Assert.Contains($"What if: Route sidecar would be written to: {sidecarPath}", result.Output);
+        Assert.Contains($"What if: Source sidecar would be written to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under -WhatIf, but found one at {sidecarPath}");
     }
 
-    // PR-route install prints the PATH-activation hint via Write-Host. The
+    // PR-source install prints the PATH-activation hint via Write-Host. The
     // OS path separator keeps the line valid on both Windows (;) and Unix (:).
     // The new-PATH expression must be double-quoted so PowerShell expands
     // `$env:PATH` when the user pastes the line into their profile — single
@@ -487,7 +487,7 @@ public async Task WhatIf_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath()
     // Separator before `$env:PATH` must be [System.IO.Path]::PathSeparator — a
     // hard-coded ":" or ";" breaks the hint on the opposite platform.
     [Fact]
-    public async Task WhatIf_PRRoute_PrintsPathHintToStdout()
+    public async Task WhatIf_PRSource_PrintsPathHintToStdout()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -510,7 +510,7 @@ public async Task WhatIf_PRRoute_PrintsPathHintToStdout()
     }
 
     [Fact]
-    public async Task WhatIf_PRRoute_PrintsPathHintWithAbsoluteInstallPath()
+    public async Task WhatIf_PRSource_PrintsPathHintWithAbsoluteInstallPath()
     {
         using var env = new TestEnvironment();
         var customPath = Path.Combine(env.TempDirectory, "custom-prefix");
@@ -541,9 +541,9 @@ private static string ExtractShellProfileHintLine(string output)
         return string.Empty;
     }
 
-    // PR-route hive location is unchanged at <prefix>/hives/pr-<N>/packages.
+    // PR-source hive location is unchanged at <prefix>/hives/pr-<N>/packages.
     [Fact]
-    public async Task WhatIf_PRRoute_HiveLocation_IsUnchanged()
+    public async Task WhatIf_PRSource_HiveLocation_IsUnchanged()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -555,12 +555,12 @@ public async Task WhatIf_PRRoute_HiveLocation_IsUnchanged()
         Assert.Contains(expectedHive, result.Output);
     }
 
-    // The PR-route script must not mutate route sidecars under -WhatIf.
-    // Companion to WhatIf_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath; kept as a
+    // The PR-source script must not mutate source sidecars under -WhatIf.
+    // Companion to WhatIf_PRSource_DoesNotWriteSidecar_AndAnnouncesPath; kept as a
     // separate test method to keep -WhatIf sidecar-absence coverage visible in
     // test inventories alongside the other -WhatIf guards.
     [Fact]
-    public async Task WhatIf_PRRoute_DoesNotWriteSidecar_AnyContentRegression()
+    public async Task WhatIf_PRSource_DoesNotWriteSidecar_AnyContentRegression()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -576,7 +576,7 @@ public async Task WhatIf_PRRoute_DoesNotWriteSidecar_AnyContentRegression()
 
     // Under -WhatIf no global aspire.config.json is created.
     [Fact]
-    public async Task WhatIf_PRRoute_DoesNotCreateGlobalAspireConfigJson()
+    public async Task WhatIf_PRSource_DoesNotCreateGlobalAspireConfigJson()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -618,7 +618,7 @@ public async Task WhatIf_LocalDir_DoesNotWriteSidecar()
         // -LocalDir without a PR number is an unmanaged install, so the script must
         // not write a sidecar; the resolver should return Unknown for these installs.
         var binSidecar = Path.Combine(env.MockHome, ".aspire", "bin", ".aspire-install.json");
-        Assert.False(File.Exists(binSidecar), $"--local-dir install must not write sidecar at {binSidecar} (unmanaged route).");
+        Assert.False(File.Exists(binSidecar), $"--local-dir install must not write sidecar at {binSidecar} (unmanaged source).");
 
         // Defensive: assert no .aspire-install.json anywhere under the install root.
         var aspireRoot = Path.Combine(env.MockHome, ".aspire");
@@ -659,7 +659,7 @@ public async Task VeryLargePRNumber_AboveIntMax_Rejected_AndCreatesNoFiles()
 
     // Non-numeric / special-char PR_NUMBER is rejected at parameter
     // binding ([int] cast or ValidateRange). This guards against path injection / command
-    // injection routes via the PR_NUMBER value.
+    // injection sources via the PR_NUMBER value.
     [Theory]
     [InlineData("../etc")]
     [InlineData("..")]
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptShellTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptShellTests.cs
index 6b778a298d2..59b3c0e1647 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptShellTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptShellTests.cs
@@ -510,13 +510,13 @@ public async Task LocalDir_DryRun_WithGitHubRunIdEnvSet_UsesLocalHiveLabel()
         Assert.DoesNotContain("run-99999", result.Output, StringComparison.OrdinalIgnoreCase);
     }
 
-    // PR-route CLI binary lands at <prefix>/dogfood/pr-<N>/bin so PR installs
-    // do not collide with the script-route prefix (<prefix>/bin) or with other PR installs.
+    // PR-source CLI binary lands at <prefix>/dogfood/pr-<N>/bin so PR installs
+    // do not collide with the script-source prefix (<prefix>/bin) or with other PR installs.
     // Under --dry-run the script emits the absolute install path via a
     // "DRYRUN: would install Aspire CLI binary to: <path>" message on stdout;
     // this test parses that message to verify the resolved install path.
     [Fact]
-    public async Task DryRun_PRRoute_CliInstallPath_IsUnderDogfoodPrN()
+    public async Task DryRun_PRSource_CliInstallPath_IsUnderDogfoodPrN()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -526,18 +526,18 @@ public async Task DryRun_PRRoute_CliInstallPath_IsUnderDogfoodPrN()
         result.EnsureSuccessful();
         var expectedBinaryPath = Path.Combine(env.MockHome, ".aspire", "dogfood", "pr-99999", "bin", "aspire");
         Assert.Contains($"DRYRUN: would install Aspire CLI binary to: {expectedBinaryPath}", result.Output);
-        var scriptRouteBin = Path.Combine(env.MockHome, ".aspire", "bin", "aspire");
-        Assert.DoesNotContain($"DRYRUN: would install Aspire CLI binary to: {scriptRouteBin}", result.Output);
+        var scriptSourceBin = Path.Combine(env.MockHome, ".aspire", "bin", "aspire");
+        Assert.DoesNotContain($"DRYRUN: would install Aspire CLI binary to: {scriptSourceBin}", result.Output);
     }
 
-    // Under --dry-run the PR-route script must NOT write the source=pr sidecar
+    // Under --dry-run the PR-source script must NOT write the source=pr sidecar
     // at <prefix>/dogfood/pr-<N>/.aspire-install.json. The describe-but-do-not-do
     // contract requires the script to print a DRYRUN message naming the path it
     // would write, then return without touching the filesystem. Positive sidecar
-    // content (the source field) for the PR route is covered by end-to-end
+    // content (the source field) for the PR source is covered by end-to-end
     // install runs, not at this unit-test layer.
     [Fact]
-    public async Task DryRun_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath()
+    public async Task DryRun_PRSource_DoesNotWriteSidecar_AndAnnouncesPath()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -547,19 +547,19 @@ public async Task DryRun_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "dogfood", "pr-99999", "bin", ".aspire-install.json");
-        Assert.Contains($"DRYRUN: would write route sidecar to: {sidecarPath}", result.Output);
+        Assert.Contains($"DRYRUN: would write source sidecar to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under --dry-run, but found one at {sidecarPath}");
     }
 
-    // PR-route install prints the PATH-activation hint to stdout so users
+    // PR-source install prints the PATH-activation hint to stdout so users
     // know how to add <prefix>/dogfood/pr-<N>/bin to their shell profile.
     //
     // Hint must carry the literal "$HOME" form, not the pre-expanded absolute path,
     // so the profile line is portable across users.
     [Fact]
-    public async Task DryRun_PRRoute_PrintsPathHintToStdout()
+    public async Task DryRun_PRSource_PrintsPathHintToStdout()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -575,7 +575,7 @@ public async Task DryRun_PRRoute_PrintsPathHintToStdout()
     }
 
     [Fact]
-    public async Task DryRun_PRRoute_PrintsPathHintWithAbsoluteInstallPath()
+    public async Task DryRun_PRSource_PrintsPathHintWithAbsoluteInstallPath()
     {
         using var env = new TestEnvironment();
         var customPath = Path.Combine(env.TempDirectory, "custom-prefix");
@@ -604,9 +604,9 @@ private static string ExtractShellProfileHintLine(string output)
         return string.Empty;
     }
 
-    // PR-route hive location is unchanged at <prefix>/hives/pr-<N>/packages.
+    // PR-source hive location is unchanged at <prefix>/hives/pr-<N>/packages.
     [Fact]
-    public async Task DryRun_PRRoute_HiveLocation_IsUnchanged()
+    public async Task DryRun_PRSource_HiveLocation_IsUnchanged()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -618,12 +618,12 @@ public async Task DryRun_PRRoute_HiveLocation_IsUnchanged()
         Assert.Contains(expectedHive, result.Output);
     }
 
-    // The PR-route script must not mutate route sidecars under --dry-run.
-    // Companion to DryRun_PRRoute_DoesNotWriteSidecar_AndAnnouncesPath; kept as a
+    // The PR-source script must not mutate source sidecars under --dry-run.
+    // Companion to DryRun_PRSource_DoesNotWriteSidecar_AndAnnouncesPath; kept as a
     // separate test method to keep dry-run sidecar-absence coverage visible in
     // test inventories alongside the other dry-run guards.
     [Fact]
-    public async Task DryRun_PRRoute_DoesNotWriteSidecar_AnyContentRegression()
+    public async Task DryRun_PRSource_DoesNotWriteSidecar_AnyContentRegression()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -639,7 +639,7 @@ public async Task DryRun_PRRoute_DoesNotWriteSidecar_AnyContentRegression()
 
     // Under --dry-run no global aspire.config.json is materialized.
     [Fact]
-    public async Task DryRun_PRRoute_DoesNotCreateGlobalAspireConfigJson()
+    public async Task DryRun_PRSource_DoesNotCreateGlobalAspireConfigJson()
     {
         using var env = new TestEnvironment();
         using var cmd = await CreateCommandWithMockGhAsync(env);
@@ -683,7 +683,7 @@ public async Task DryRun_LocalDir_DoesNotWriteSidecar()
         // --local-dir without a PR number is an unmanaged install, so the script must
         // not write a sidecar; the resolver should return Unknown for these installs.
         var binSidecar = Path.Combine(env.MockHome, ".aspire", "bin", ".aspire-install.json");
-        Assert.False(File.Exists(binSidecar), $"--local-dir install must not write sidecar at {binSidecar} (unmanaged route).");
+        Assert.False(File.Exists(binSidecar), $"--local-dir install must not write sidecar at {binSidecar} (unmanaged source).");
 
         // Defensive: walk the .aspire root and assert no sidecar landed at any depth.
         var aspireRoot = Path.Combine(env.MockHome, ".aspire");
@@ -723,7 +723,7 @@ public async Task VeryLargePRNumber_AcceptedByScript_DryRunAnnouncesSidecarPath(
 
         result.EnsureSuccessful();
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "dogfood", "pr-99999999999", "bin", ".aspire-install.json");
-        Assert.Contains($"DRYRUN: would write route sidecar to: {sidecarPath}", result.Output);
+        Assert.Contains($"DRYRUN: would write source sidecar to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under --dry-run, but found one at {sidecarPath}");
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptToolModeTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptToolModeTests.cs
index f329ac83d2e..f55b0188869 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/PRScriptToolModeTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/PRScriptToolModeTests.cs
@@ -250,7 +250,7 @@ public async Task Bash_ToolMode_PrDryRun_SkipsCliNativeArchivesDownload()
         Assert.Contains("built-nugets-for-", result.Output);
         Assert.Contains("dotnet tool install --global Aspire.Cli", result.Output);
         Assert.DoesNotContain("config set channel", result.Output);
-        Assert.DoesNotContain("route sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("source sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("dogfood/pr-12345/bin", result.Output);
         Assert.DoesNotContain(".dotnet/tools", result.Output);
     }
@@ -481,7 +481,7 @@ public async Task Bash_ToolMode_ForceUpdateFailureReportsUpdate()
 
     [Fact]
     [SkipOnPlatform(TestPlatforms.Windows, "Bash script tests require bash shell")]
-    public async Task Bash_ToolMode_PrInstall_DoesNotWritePRRouteSidecar()
+    public async Task Bash_ToolMode_PrInstall_DoesNotWritePRSourceSidecar()
     {
         using var env = new TestEnvironment();
         var mockGhPath = await env.CreateMockGhScriptAsync(_testOutput);
@@ -504,7 +504,7 @@ public async Task Bash_ToolMode_PrInstall_DoesNotWritePRRouteSidecar()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "dogfood", "pr-12345", "bin", ".aspire-install.json");
-        Assert.False(File.Exists(sidecarPath), $"Tool mode must not write the PR-route sidecar at {sidecarPath}.");
+        Assert.False(File.Exists(sidecarPath), $"Tool mode must not write the PR-source sidecar at {sidecarPath}.");
         // Tool mode now populates the PR hive so `aspire new`/`aspire run` can
         // resolve the PR version of Aspire.AppHost.Sdk and friends.
         var prHive = Path.Combine(env.MockHome, ".aspire", "hives", "pr-12345", "packages");
@@ -829,7 +829,7 @@ public async Task Ps_ToolMode_PrWhatIf_SkipsCliNativeArchivesDownload()
         Assert.Contains("built-nugets-for-", result.Output);
         Assert.Contains("dotnet tool install --global Aspire.Cli", result.Output);
         Assert.DoesNotContain("config set channel", result.Output);
-        Assert.DoesNotContain("route sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
+        Assert.DoesNotContain("source sidecar", result.Output, StringComparison.OrdinalIgnoreCase);
         Assert.DoesNotContain("dogfood", result.Output);
         Assert.DoesNotContain(".dotnet", result.Output);
     }
@@ -1025,7 +1025,7 @@ public async Task Ps_ToolMode_ForceUpdatesExistingToolWithAllowDowngrade()
 
     [Fact]
     [RequiresTools(["pwsh"])]
-    public async Task Ps_ToolMode_PrInstall_DoesNotWritePRRouteSidecar()
+    public async Task Ps_ToolMode_PrInstall_DoesNotWritePRSourceSidecar()
     {
         using var env = new TestEnvironment();
         var mockGhPath = await env.CreateMockGhScriptAsync(_testOutput);
@@ -1048,7 +1048,7 @@ public async Task Ps_ToolMode_PrInstall_DoesNotWritePRRouteSidecar()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "dogfood", "pr-12345", "bin", ".aspire-install.json");
-        Assert.False(File.Exists(sidecarPath), $"Tool mode must not write the PR-route sidecar at {sidecarPath}.");
+        Assert.False(File.Exists(sidecarPath), $"Tool mode must not write the PR-source sidecar at {sidecarPath}.");
         // Tool mode now populates the PR hive so `aspire new`/`aspire run` can
         // resolve the PR version of Aspire.AppHost.Sdk and friends.
         var prHive = Path.Combine(env.MockHome, ".aspire", "hives", "pr-12345", "packages");
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptPowerShellTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptPowerShellTests.cs
index cc56384473b..cb9c5579d72 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptPowerShellTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptPowerShellTests.cs
@@ -263,7 +263,7 @@ public async Task Install_DryRun_DoesNotWriteGlobalChannelField()
             $"install.ps1 must not create global aspire.config.json; found at {configPath}.");
     }
 
-    // Under -WhatIf the release-route script must NOT write the script-route
+    // Under -WhatIf the release-source script must NOT write the script-source
     // sidecar at <prefix>/.aspire-install.json. The describe-but-do-not-do
     // contract requires the script to print a "What if:" message naming the path
     // it would write, then return without touching the filesystem. A previous
@@ -271,7 +271,7 @@ public async Task Install_DryRun_DoesNotWriteGlobalChannelField()
     // can leave a stale source=script marker visible to BundleService when
     // the install was never actually performed.
     [Fact]
-    public async Task WhatIf_DoesNotWriteScriptRouteSidecar_AndAnnouncesPath()
+    public async Task WhatIf_DoesNotWriteScriptSourceSidecar_AndAnnouncesPath()
     {
         using var env = new TestEnvironment();
         using var cmd = new ScriptToolCommand(s_scriptPath, env, _testOutput);
@@ -280,16 +280,16 @@ public async Task WhatIf_DoesNotWriteScriptRouteSidecar_AndAnnouncesPath()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "bin", ".aspire-install.json");
-        Assert.Contains($"What if: Route sidecar would be written to: {sidecarPath}", result.Output);
+        Assert.Contains($"What if: Source sidecar would be written to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under -WhatIf, but found one at {sidecarPath}");
     }
 
-    // The release-route script must not mutate route sidecars under -WhatIf,
+    // The release-source script must not mutate source sidecars under -WhatIf,
     // regardless of the configured quality.
     [Fact]
-    public async Task WhatIf_DevQuality_DoesNotWriteScriptRouteSidecar()
+    public async Task WhatIf_DevQuality_DoesNotWriteScriptSourceSidecar()
     {
         using var env = new TestEnvironment();
         using var cmd = new ScriptToolCommand(s_scriptPath, env, _testOutput);
@@ -298,7 +298,7 @@ public async Task WhatIf_DevQuality_DoesNotWriteScriptRouteSidecar()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "bin", ".aspire-install.json");
-        Assert.Contains($"What if: Route sidecar would be written to: {sidecarPath}", result.Output);
+        Assert.Contains($"What if: Source sidecar would be written to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under -WhatIf, but found one at {sidecarPath}");
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptShellTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptShellTests.cs
index 60afa22b126..3b8ad6a3ba8 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptShellTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/ReleaseScriptShellTests.cs
@@ -214,7 +214,7 @@ public async Task Install_DryRun_DoesNotWriteGlobalChannelField()
             $"install.sh must not create global aspire.config.json; found at {configPath}.");
     }
 
-    // Under --dry-run the release-route script must NOT write the script-route
+    // Under --dry-run the release-source script must NOT write the script-source
     // sidecar at <prefix>/.aspire-install.json. The describe-but-do-not-do
     // contract requires the script to print a DRYRUN message naming the path it
     // would write, then return without touching the filesystem. A previous
@@ -222,7 +222,7 @@ public async Task Install_DryRun_DoesNotWriteGlobalChannelField()
     // stale source=script marker visible to BundleService when the install
     // was never actually performed.
     [Fact]
-    public async Task DryRun_DoesNotWriteScriptRouteSidecar_AndAnnouncesPath()
+    public async Task DryRun_DoesNotWriteScriptSourceSidecar_AndAnnouncesPath()
     {
         using var env = new TestEnvironment();
         using var cmd = new ScriptToolCommand(s_scriptPath, env, _testOutput);
@@ -231,18 +231,18 @@ public async Task DryRun_DoesNotWriteScriptRouteSidecar_AndAnnouncesPath()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "bin", ".aspire-install.json");
-        Assert.Contains($"DRYRUN: would write route sidecar to: {sidecarPath}", result.Output);
+        Assert.Contains($"DRYRUN: would write source sidecar to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under --dry-run, but found one at {sidecarPath}");
     }
 
-    // The release-route script must not mutate route sidecars under --dry-run,
+    // The release-source script must not mutate source sidecars under --dry-run,
     // regardless of the configured quality. This guards the dry-run contract on
     // the 'dev' quality path, which historically took a slightly different
     // code branch in the script body.
     [Fact]
-    public async Task DryRun_DevQuality_DoesNotWriteScriptRouteSidecar()
+    public async Task DryRun_DevQuality_DoesNotWriteScriptSourceSidecar()
     {
         using var env = new TestEnvironment();
         using var cmd = new ScriptToolCommand(s_scriptPath, env, _testOutput);
@@ -251,7 +251,7 @@ public async Task DryRun_DevQuality_DoesNotWriteScriptRouteSidecar()
         result.EnsureSuccessful();
 
         var sidecarPath = Path.Combine(env.MockHome, ".aspire", "bin", ".aspire-install.json");
-        Assert.Contains($"DRYRUN: would write route sidecar to: {sidecarPath}", result.Output);
+        Assert.Contains($"DRYRUN: would write source sidecar to: {sidecarPath}", result.Output);
         Assert.False(
             File.Exists(sidecarPath),
             $"Expected no sidecar to be written under --dry-run, but found one at {sidecarPath}");
diff --git a/tests/Aspire.Acquisition.Tests/Scripts/VerifyCliArchivePowerShellTests.cs b/tests/Aspire.Acquisition.Tests/Scripts/VerifyCliArchivePowerShellTests.cs
index e83ba1aeaed..db5f4c56c46 100644
--- a/tests/Aspire.Acquisition.Tests/Scripts/VerifyCliArchivePowerShellTests.cs
+++ b/tests/Aspire.Acquisition.Tests/Scripts/VerifyCliArchivePowerShellTests.cs
@@ -33,7 +33,7 @@ public async Task VerifyCliArchive_AcceptsCleanPerRidArchive()
         result.EnsureSuccessful();
         Assert.Contains("aspire mock v1.0", result.Output);
         Assert.Contains("'aspire new aspire-starter' created project successfully", result.Output);
-        Assert.Contains("linux-* archive correctly omits the install-route sidecar", result.Output);
+        Assert.Contains("linux-* archive correctly omits the install-source sidecar", result.Output);
         Assert.Contains("All verification checks passed", result.Output);
     }
 
@@ -54,7 +54,7 @@ public async Task VerifyCliArchive_RejectsArchiveWithStraySidecar()
         // The exact error wording is part of the verifier's user-facing contract; see
         // eng/scripts/verify-cli-archive.ps1 Test-ArchiveSidecar.
         Assert.Contains(".aspire-install.json", result.Output);
-        Assert.Contains("per-RID archives are shared across install routes", result.Output);
+        Assert.Contains("per-RID archives are shared across install sources", result.Output);
     }
 
     [Fact]
@@ -80,6 +80,6 @@ public async Task VerifyCliArchive_RejectsStraySidecarWhenBinaryIsNestedUnderSub
 
         Assert.NotEqual(0, result.ExitCode);
         Assert.Contains(".aspire-install.json", result.Output);
-        Assert.Contains("per-RID archives are shared across install routes", result.Output);
+        Assert.Contains("per-RID archives are shared across install sources", result.Output);
     }
 }
diff --git a/tests/Aspire.Cli.Tests/Acquisition/InstallSidecarReaderTests.cs b/tests/Aspire.Cli.Tests/Acquisition/InstallSidecarReaderTests.cs
index e8bc04232ae..e04ae6667ab 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/InstallSidecarReaderTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/InstallSidecarReaderTests.cs
@@ -9,9 +9,9 @@ namespace Aspire.Cli.Tests.Acquisition;
 
 /// <summary>
 /// Behavior tests for <see cref="InstallSidecarReader"/>. The sidecar contract
-/// is documented in <c>docs/specs/install-routes.md</c>: a single-field JSON
+/// is documented in <c>docs/specs/install-sources.md</c>: a single-field JSON
 /// file named <c>.aspire-install.json</c> with shape
-/// <c>{ "source": "&lt;route&gt;" }</c> living next to the CLI binary.
+/// <c>{ "source": "&lt;source&gt;" }</c> living next to the CLI binary.
 /// </summary>
 public class InstallSidecarReaderTests(ITestOutputHelper outputHelper)
 {
@@ -19,7 +19,7 @@ public class InstallSidecarReaderTests(ITestOutputHelper outputHelper)
     [InlineData("script", "Script")]
     [InlineData("pr", "Pr")]
     [InlineData("winget", "Winget")]
-    [InlineData("brew", "Brew")]
+    [InlineData("brew", "Homebrew")]
     [InlineData("dotnet-tool", "DotnetTool")]
     [InlineData("localhive", "LocalHive")]
     public void TryRead_ParsesEachKnownSource(string wireValue, string expectedEnumName)
@@ -108,13 +108,13 @@ public void TryRead_MalformedJson_ReturnsInvalidWithParseReason()
 
     [Theory]
     [InlineData("{\"source\":\"\"}",          "",             "empty source string")]
-    [InlineData("{\"source\":\"future-route\"}", "future-route", "unknown but well-formed source")]
+    [InlineData("{\"source\":\"future-source\"}", "future-source", "unknown but well-formed source")]
     [InlineData("[\"script\"]",               "",             "non-object root element")]
     [InlineData("{\"source\": 42}",           "",             "non-string source field")]
     public void TryRead_UnknownOrMalformedSource_ReturnsUnknownEnumWithRawSourcePreserved(string sidecarBody, string expectedRawSource, string scenario)
     {
         // All four shapes round-trip via the parser as InstallSource.Unknown so
-        // a future-route or otherwise-unrecognized sidecar never blocks the
+        // a future-source or otherwise-unrecognized sidecar never blocks the
         // discovery walk. RawSource preserves the literal wire value so a
         // future client can re-interpret it without re-reading the file.
         _ = scenario; // surfaced in test name for debuggability
@@ -207,7 +207,7 @@ public void ReadSourceField_UnreadableSidecar_ReturnsNull()
     [InlineData("Script", "script")]
     [InlineData("Pr", "pr")]
     [InlineData("Winget", "winget")]
-    [InlineData("Brew", "brew")]
+    [InlineData("Homebrew", "brew")]
     [InlineData("DotnetTool", "dotnet-tool")]
     [InlineData("LocalHive", "localhive")]
     public void ToWireString_RoundTripsWithParseInstallSource(string enumName, string expectedWire)
diff --git a/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs b/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs
index 01a0a6f3052..f73d14ba541 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs
@@ -33,7 +33,7 @@ public async Task DiscoverAllAsync_PathHit_WithoutSidecar_IsListedAsNotProbed_An
     {
         // A binary on $PATH with no .aspire-install.json next to it must not be
         // spawned. The user-installed binary on PATH is the most dangerous case:
-        // if a user runs `aspire doctor`, we cannot execute arbitrary
+        // if a user runs `aspire --info`, we cannot execute arbitrary
         // same-named binaries we happened to find.
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var pathDir = Path.Combine(workspace.WorkspaceRoot.FullName, "no-sidecar-bin");
@@ -53,7 +53,7 @@ public async Task DiscoverAllAsync_PathHit_WithoutSidecar_IsListedAsNotProbed_An
             string.Equals(r.CanonicalPath, noSidecarBinary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal(InstallationInfoStatus.NotProbed, noSidecarRow.Status);
         var expectedSidecarPath = Path.Combine(pathDir, InstallSidecarReader.SidecarFileName);
-        Assert.Equal($"No install-route sidecar found at {expectedSidecarPath}; peer was not probed.", noSidecarRow.StatusReason);
+        Assert.Equal($"No install-source sidecar found at {expectedSidecarPath}; peer was not probed.", noSidecarRow.StatusReason);
     }
 
     [Fact]
@@ -86,7 +86,7 @@ public async Task DiscoverAllAsync_PathHit_WithUnreadableSidecar_IsListedAsNotPr
             Assert.DoesNotContain(probe.ProbedPaths, p => string.Equals(p, binary, StringComparison.Ordinal));
             var row = Assert.Single(results, r => string.Equals(r.CanonicalPath, binary, StringComparison.Ordinal));
             Assert.Equal(InstallationInfoStatus.NotProbed, row.Status);
-            Assert.Equal($"Install-route sidecar at {sidecarPath} could not be read or parsed; peer was not probed.", row.StatusReason);
+            Assert.Equal($"Install-source sidecar at {sidecarPath} could not be read or parsed; peer was not probed.", row.StatusReason);
         }
         finally
         {
@@ -114,13 +114,13 @@ public async Task DiscoverAllAsync_PathHit_WithMalformedSidecar_IsListedAsNotPro
         var row = Assert.Single(results, r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal(InstallationInfoStatus.NotProbed, row.Status);
-        Assert.Equal($"Install-route sidecar at {sidecarPath} could not be read or parsed; peer was not probed.", row.StatusReason);
+        Assert.Equal($"Install-source sidecar at {sidecarPath} could not be read or parsed; peer was not probed.", row.StatusReason);
     }
 
     [Fact]
     public async Task DiscoverAllAsync_TrustedSidecar_IsSpawnedAndDecoratedWithDiscoveredPath()
     {
-        // A binary with a script-route sidecar in its directory has enough
+        // A binary with a script-source sidecar in its directory has enough
         // install metadata to be probed. The peer probe is called, and its returned
         // InstallationInfo is merged with the discovered path so the row
         // displayed to the user matches what `which` would show.
@@ -137,7 +137,7 @@ public async Task DiscoverAllAsync_TrustedSidecar_IsSpawnedAndDecoratedWithDisco
                 Path = "/peer-says/aspire",
                 Version = "12.5.0",
                 Channel = "stable",
-                Route = "script",
+                Source = "script",
                 Status = InstallationInfoStatus.Ok,
             }),
         });
@@ -212,7 +212,7 @@ public async Task DiscoverAllAsync_PathStatusTracksActiveShadowedAndOffPathInsta
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_UnknownSidecarSource_WithSuccessfulProbe_ProbesAndSurfacesRawRoute()
+    public async Task DiscoverAllAsync_UnknownSidecarSource_WithSuccessfulProbe_ProbesAndSurfacesRawSource()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var binDir = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire", "bin");
@@ -237,13 +237,13 @@ public async Task DiscoverAllAsync_UnknownSidecarSource_WithSuccessfulProbe_Prob
         var row = results.Single(r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal(InstallationInfoStatus.Ok, row.Status);
-        Assert.Equal("apt", row.Route);
+        Assert.Equal("apt", row.Source);
         Assert.Equal("13.1.0", row.Version);
         Assert.Equal("daily", row.Channel);
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_UnknownSidecarSource_WithFailedProbe_ProbesAndSurfacesFailedWithRawRoute()
+    public async Task DiscoverAllAsync_UnknownSidecarSource_WithFailedProbe_ProbesAndSurfacesFailedWithRawSource()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var binDir = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire", "bin");
@@ -262,15 +262,15 @@ public async Task DiscoverAllAsync_UnknownSidecarSource_WithFailedProbe_ProbesAn
         var row = results.Single(r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal(InstallationInfoStatus.Failed, row.Status);
-        Assert.Equal("apt", row.Route);
+        Assert.Equal("apt", row.Source);
         Assert.Equal("simulated probe failure", row.StatusReason);
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_PeerProbeFails_RowSurvivesAsFailed_WithRouteIntact()
+    public async Task DiscoverAllAsync_PeerProbeFails_RowSurvivesAsFailed_WithSourceIntact()
     {
         // A peer that fails (timeout / non-zero exit / invalid JSON) is per-row,
-        // not whole-command. The route from the sidecar is still surfaced so the
+        // not whole-command. The source from the sidecar is still surfaced so the
         // user sees "this is a PR install but it wouldn't talk to me", not nothing.
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var prDir = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire", "dogfood", "pr-9999", "bin");
@@ -289,7 +289,7 @@ public async Task DiscoverAllAsync_PeerProbeFails_RowSurvivesAsFailed_WithRouteI
         var row = results.Single(r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal(InstallationInfoStatus.Failed, row.Status);
-        Assert.Equal("pr", row.Route);
+        Assert.Equal("pr", row.Source);
         Assert.Contains("simulated peer hang", row.StatusReason!);
     }
 
@@ -345,7 +345,7 @@ public async Task DiscoverAllAsync_ProbeFailureAndMissingInstallMetadata_Surface
         if (hasInstallMetadata)
         {
             Assert.Contains(probe.ProbedPaths, p => string.Equals(p, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
-            Assert.Equal("script", row.Route);
+            Assert.Equal("script", row.Source);
             Assert.Contains("peer returned malformed JSON", row.StatusReason!);
         }
         else
@@ -356,7 +356,7 @@ public async Task DiscoverAllAsync_ProbeFailureAndMissingInstallMetadata_Surface
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_PrRoute_DerivesChannelFromDogfoodPathWhenPeerOmits()
+    public async Task DiscoverAllAsync_PrSource_DerivesChannelFromDogfoodPathWhenPeerOmits()
     {
         // The structural channel for a PR install is `pr-<N>` regardless
         // of whether the older peer's --version output includes channel
@@ -385,12 +385,12 @@ public async Task DiscoverAllAsync_PrRoute_DerivesChannelFromDogfoodPathWhenPeer
         var prRow = results.Single(r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal("pr-12345", prRow.Channel);
-        Assert.Equal("pr", prRow.Route);
+        Assert.Equal("pr", prRow.Source);
         Assert.Equal("13.4.0-pr.12345.gabcdef", prRow.Version);
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_PrRoute_DoesNotOverwritePeerReportedChannel()
+    public async Task DiscoverAllAsync_PrSource_DoesNotOverwritePeerReportedChannel()
     {
         // When the peer DOES report a channel, the discovery layer must not overwrite it
         // with the path-derived value, even if they happen to match.
@@ -422,14 +422,14 @@ public async Task DiscoverAllAsync_PrRoute_DoesNotOverwritePeerReportedChannel()
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_BrewRoute_DerivesPrChannelFromVersionWhenPeerOmits()
+    public async Task DiscoverAllAsync_BrewSource_DerivesPrChannelFromVersionWhenPeerOmits()
     {
-        // Brew-installed PR builds (e.g. from `brew install aspire@pr-N`) live
+        // Homebrew-installed PR builds (e.g. from `homebrew install aspire@pr-N`) live
         // under a path that doesn't carry the `dogfood/pr-<N>/bin` shape, so
         // the path-based derivation can't help. The version string, on the
         // other hand, IS baked at build time as `<x.y.z>-pr.<N>.<hash>` —
-        // discovery should fall back to that signal so older brew peers,
-        // which don't recognize the `doctor --self` self-describe contract,
+        // discovery should fall back to that signal so older homebrew peers,
+        // which don't recognize the `--info --self` self-describe contract,
         // still surface their channel instead of "(unknown)".
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var brewDir = Path.Combine(workspace.WorkspaceRoot.FullName, "Caskroom", "aspire", "13.4.0-pr.17115.gcd700928");
@@ -439,7 +439,7 @@ public async Task DiscoverAllAsync_BrewRoute_DerivesPrChannelFromVersionWhenPeer
 
         var probe = new FakePeerInstallProbe(new Dictionary<string, PeerProbeResult>
         {
-            // Older brew peer: doctor --self unsupported, so the probe
+            // Older homebrew peer: --info --self unsupported, so the probe
             // took the --version fallback path and reported version only.
             [binary] = new PeerProbeResult.Ok(new InstallationInfo
             {
@@ -456,12 +456,12 @@ public async Task DiscoverAllAsync_BrewRoute_DerivesPrChannelFromVersionWhenPeer
         var brewRow = results.Single(r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Equal("pr-17115", brewRow.Channel);
-        Assert.Equal("brew", brewRow.Route);
+        Assert.Equal("brew", brewRow.Source);
         Assert.Equal("13.4.0-pr.17115.gcd700928", brewRow.Version);
     }
 
     [Fact]
-    public async Task DiscoverAllAsync_BrewRoute_LeavesChannelNullForStableVersion()
+    public async Task DiscoverAllAsync_BrewSource_LeavesChannelNullForStableVersion()
     {
         // Same shape as the previous test, but with a non-PR version. The
         // version-based derivation must return null (we can't recover the
@@ -490,7 +490,7 @@ public async Task DiscoverAllAsync_BrewRoute_LeavesChannelNullForStableVersion()
         var brewRow = results.Single(r =>
             string.Equals(r.CanonicalPath, binary, OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
         Assert.Null(brewRow.Channel);
-        Assert.Equal("brew", brewRow.Route);
+        Assert.Equal("brew", brewRow.Source);
     }
 
     [Theory]
@@ -568,7 +568,7 @@ public async Task DiscoverAllAsync_LogsInstallMetadataRejection_AtDebugLevel()
     {
         // When the install metadata check rejects a candidate (no sidecar), the user
         // should see why in --log-level debug output. Without this, an
-        // install that "doesn't show up correctly" in `aspire doctor`
+        // install that "doesn't show up correctly" in `aspire --info`
         // is hard to diagnose.
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var pathDir = Path.Combine(workspace.WorkspaceRoot.FullName, "no-sidecar-bin");
@@ -763,7 +763,7 @@ public async Task DiscoverAllAsync_HonorsExecutionContextHomeDirectory_WithoutEn
                 Path = binary,
                 Version = "13.4.0",
                 Channel = "stable",
-                Route = "script",
+                Source = "script",
                 Status = InstallationInfoStatus.Ok,
             }),
         });
@@ -793,7 +793,7 @@ public async Task DiscoverAllAsync_UsesAspireHomeDirectoryForPortableInstallPref
                 Path = binary,
                 Version = "13.4.0",
                 Channel = "local",
-                Route = "localhive",
+                Source = "localhive",
                 Status = InstallationInfoStatus.Ok,
             }),
         });
@@ -861,7 +861,7 @@ public async Task DiscoverAllAsync_OnMacOS_DedupsSelfAgainstPathHit_AcrossFirmli
                 CanonicalPath = binary,
                 Version = "test-version",
                 Channel = "pr-99999",
-                Route = "pr",
+                Source = "pr",
                 Status = InstallationInfoStatus.Ok,
             }),
         });
diff --git a/tests/Aspire.Cli.Tests/BundleServiceComputeDefaultExtractDirTests.cs b/tests/Aspire.Cli.Tests/BundleServiceComputeDefaultExtractDirTests.cs
index 8c8a7de28b8..be1448c0e0a 100644
--- a/tests/Aspire.Cli.Tests/BundleServiceComputeDefaultExtractDirTests.cs
+++ b/tests/Aspire.Cli.Tests/BundleServiceComputeDefaultExtractDirTests.cs
@@ -10,7 +10,7 @@ namespace Aspire.Cli.Tests;
 // distribution shape that ships an .aspire-install.json sidecar must land
 // extraction at the install prefix the packager owns so versions/<id>/ stays
 // inside the directory the packager actually manages. These tests construct the
-// real on-disk layout each route produces, then assert the helper picks the
+// real on-disk layout each source produces, then assert the helper picks the
 // directory whose versions/ subdirectory the bundle should populate. They are
 // the regression net against a packager moving the sidecar or the bundle
 // pipeline changing its switch on the sidecar's source field.
@@ -23,7 +23,7 @@ public class BundleServiceComputeDefaultExtractDirTests
     [InlineData("localhive")] // localhive.{sh,ps1}
     public void ComputeDefaultExtractDir_SharedPrefixSource_ReturnsParentOfBinaryDir(string source)
     {
-        // Both the get-aspire-cli script route and the localhive route lay the
+        // Both the get-aspire-cli script source and the localhive source lay the
         // CLI out at <prefix>/bin/aspire with a colocated .aspire-install.json,
         // so extraction must land at <prefix>/ (parent of the binary's dir) so
         // the eventual versions/<id>/ tree sits next to the bin/ directory
@@ -49,7 +49,7 @@ public void ComputeDefaultExtractDir_PRSource_ReturnsPRSubprefix()
         // dogfood/pr-<N>/bin subdirectory with its own colocated sidecar. The
         // sidecar value is always source=pr; the per-PR namespace lives in the
         // directory layout. Extraction must land at the dogfood/pr-<N>/ directory
-        // — not the outer install root — to keep stable and PR-route versions/
+        // — not the outer install root — to keep stable and PR-source versions/
         // trees from colliding.
         using var temp = new TestTempDirectory();
         var prDir = Path.Combine(temp.Path, "dogfood", "pr-12345");
@@ -88,13 +88,13 @@ public void ComputeDefaultExtractDir_WingetSource_ReturnsInstallDirectory()
     [Fact]
     public void ComputeDefaultExtractDir_BrewSymlinkSource_ReturnsCellarPrefix_NotSymlinkParent()
     {
-        // Regression net for the brew bug: /opt/homebrew/bin/aspire is a symlink into
+        // Regression net for the homebrew bug: /opt/homebrew/bin/aspire is a symlink into
         // the cellar (e.g. /opt/homebrew/Caskroom/aspire/<version>/aspire) where the
-        // brew cask writes the binary AND .aspire-install.json side-by-side. The helper
+        // homebrew cask writes the binary AND .aspire-install.json side-by-side. The helper
         // follows the symlink before sidecar lookup; extraction must land at the cellar
         // prefix so `brew uninstall aspire` (which wipes that prefix per the cask
         // template) cleans the versions/<id>/ tree too. Using the symlink's parent
-        // (/opt/homebrew/) would leak versions/ outside brew's ownership.
+        // (/opt/homebrew/) would leak versions/ outside homebrew's ownership.
         Assert.SkipUnless(OperatingSystem.IsLinux() || OperatingSystem.IsMacOS(),
             "Symlink resolution test only runs on Linux/macOS where unprivileged symlink creation is reliable.");
 
diff --git a/tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossRouteExtractionTests.cs b/tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossSourceExtractionTests.cs
similarity index 93%
rename from tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossRouteExtractionTests.cs
rename to tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossSourceExtractionTests.cs
index 6e039eb43ab..39bfc306038 100644
--- a/tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossRouteExtractionTests.cs
+++ b/tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossSourceExtractionTests.cs
@@ -8,14 +8,14 @@ namespace Aspire.Cli.Tests.Bundles;
 
 /// <summary>
 /// Verifies <see cref="BundleService.ComputeDefaultExtractDir(string)"/> against
-/// every (source × prefix shape) combination the supported install routes produce.
+/// every (source × prefix shape) combination the supported install sources produce.
 /// The matrix locks in the contract: the reader walks the sidecar's
 /// <c>source</c> field — and nothing else — to decide between
-/// <c>binaryDir</c> (winget / brew / dotnet-tool) and the parent of
+/// <c>binaryDir</c> (winget / homebrew / dotnet-tool) and the parent of
 /// <c>binaryDir</c> (script / pr / localhive). Missing, invalid, or unknown sidecars fall
 /// through to the default Aspire home.
 /// </summary>
-public class BundleServiceCrossRouteExtractionTests
+public class BundleServiceCrossSourceExtractionTests
 {
     private const string DefaultAspireHome = "<default-aspire-home>";
 
@@ -26,7 +26,7 @@ public class BundleServiceCrossRouteExtractionTests
     // 1) winget canonical: WinGet places the portable binary in a per-package
     //    versioned directory; the bundle payload lives in that same directory.
     [InlineData("winget", "WinGet/Packages/Microsoft.Aspire_Microsoft.Winget.Source_8wekyb3d8bbwe/aspire.exe", "WinGet/Packages/Microsoft.Aspire_Microsoft.Winget.Source_8wekyb3d8bbwe")]
-    // 2) brew canonical: Homebrew cellar with versioned cask directory.
+    // 2) homebrew canonical: Homebrew cellar with versioned cask directory.
     [InlineData("brew", "Caskroom/aspire/13.2.0/aspire", "Caskroom/aspire/13.2.0")]
     // 3) dotnet-tool canonical: dotnet's global-tools shim at ~/.dotnet/tools/aspire
     //    delegates (apphost launch on Windows; symlink follow on Unix) to the
@@ -40,7 +40,7 @@ public class BundleServiceCrossRouteExtractionTests
     [InlineData("pr", ".aspire/dogfood/pr-16817/bin/aspire", ".aspire/dogfood/pr-16817")]
     // 6) localhive canonical: local dev hive with the same bin layout as script.
     [InlineData("localhive", ".aspire/local/bin/aspire", ".aspire/local")]
-    // 7) Cross-route smuggle case: a brew-source sidecar dropped into a
+    // 7) Cross-source smuggle case: a homebrew-source sidecar dropped into a
     //    script-layout prefix MUST resolve to binaryDir per the switch — the
     //    reader is honest about whatever the producer put on disk. When the
     //    producer side correctly suppresses the smuggled sidecar, this row's
@@ -58,7 +58,7 @@ public class BundleServiceCrossRouteExtractionTests
     // 11) Sidecar with an unknown source value: switch default arm, same as
     //     missing sidecar — default Aspire home.
     [InlineData("github-actions", ".aspire/bin/aspire", DefaultAspireHome)]
-    public void ComputeDefaultExtractDir_RouteAndPrefixCombinations_ProduceExpectedExtractDir(
+    public void ComputeDefaultExtractDir_SourceAndPrefixCombinations_ProduceExpectedExtractDir(
         string? sourceField,
         string relativeProcessPath,
         string relativeExpectedExtractDir)
diff --git a/tests/Aspire.Cli.Tests/Utils/CliPathHelperTests.cs b/tests/Aspire.Cli.Tests/Utils/CliPathHelperTests.cs
index f6b3cd19ab3..702ca893fcd 100644
--- a/tests/Aspire.Cli.Tests/Utils/CliPathHelperTests.cs
+++ b/tests/Aspire.Cli.Tests/Utils/CliPathHelperTests.cs
@@ -55,27 +55,27 @@ public void CreateUnixDomainSocketPath_UsesRandomizedIdentifier()
     [Theory]
     [InlineData("script")]
     [InlineData("localhive")]
-    public void TryGetAspireHomeDirectoryFromInstallRoute_SharedPrefixRoute_ReturnsInstallPrefix(string source)
+    public void TryGetAspireHomeDirectoryFromInstallSource_SharedPrefixSource_ReturnsInstallPrefix(string source)
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var installPrefix = Path.Combine(workspace.WorkspaceRoot.FullName, "aspire");
         var binDir = Path.Combine(installPrefix, "bin");
         var binaryPath = WriteBinaryWithSidecar(binDir, source);
 
-        var result = CliPathHelper.TryGetAspireHomeDirectoryFromInstallRoute(binaryPath);
+        var result = CliPathHelper.TryGetAspireHomeDirectoryFromInstallSource(binaryPath);
 
         Assert.Equal(installPrefix, result);
     }
 
     [Fact]
-    public void TryGetAspireHomeDirectoryFromInstallRoute_PrRoute_ReturnsOuterInstallPrefix()
+    public void TryGetAspireHomeDirectoryFromInstallSource_PrSource_ReturnsOuterInstallPrefix()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var installPrefix = Path.Combine(workspace.WorkspaceRoot.FullName, "aspire-pr-test");
         var binDir = Path.Combine(installPrefix, "dogfood", "pr-17159", "bin");
         var binaryPath = WriteBinaryWithSidecar(binDir, "pr");
 
-        var result = CliPathHelper.TryGetAspireHomeDirectoryFromInstallRoute(binaryPath);
+        var result = CliPathHelper.TryGetAspireHomeDirectoryFromInstallSource(binaryPath);
 
         Assert.Equal(installPrefix, result);
     }
@@ -85,18 +85,18 @@ public void TryGetAspireHomeDirectoryFromInstallRoute_PrRoute_ReturnsOuterInstal
     [InlineData("winget")]
     [InlineData("dotnet-tool")]
     [InlineData("unknown")]
-    public void TryGetAspireHomeDirectoryFromInstallRoute_PackageManagerOrUnknownRoute_ReturnsNull(string source)
+    public void TryGetAspireHomeDirectoryFromInstallSource_PackageManagerOrUnknownSource_ReturnsNull(string source)
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var binaryPath = WriteBinaryWithSidecar(workspace.WorkspaceRoot.FullName, source);
 
-        var result = CliPathHelper.TryGetAspireHomeDirectoryFromInstallRoute(binaryPath);
+        var result = CliPathHelper.TryGetAspireHomeDirectoryFromInstallSource(binaryPath);
 
         Assert.Null(result);
     }
 
     [Fact]
-    public void GetAspireHomeDirectory_PrRoute_UsesOuterInstallPrefix()
+    public void GetAspireHomeDirectory_PrSource_UsesOuterInstallPrefix()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var installPrefix = Path.Combine(workspace.WorkspaceRoot.FullName, "portable");
@@ -263,7 +263,7 @@ public void ResolveSymlinkOrOriginalPath_OnMacOS_StripsFirmlinkPrefix()
 
     [Fact]
     [SkipOnPlatform(TestPlatforms.Windows | TestPlatforms.Linux, "Firmlink propagation only applies on macOS.")]
-    public void GetAspireHomeDirectory_OnMacOS_PrRouteWithFirmlinkedProcessPath_ReturnsUnfirmlinkedPrefix()
+    public void GetAspireHomeDirectory_OnMacOS_PrSourceWithFirmlinkedProcessPath_ReturnsUnfirmlinkedPrefix()
     {
         // Bug B regression: when Environment.ProcessPath comes back firmlinked (/private/var/...),
         // every derivation hanging off it (AspireHome → HivesDirectory → PackagingService source path)

From 85a1752ebe3011cdf592c722021b996256d72d75 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 26 May 2026 19:08:37 -0400
Subject: [PATCH 02/15] fix(cli): preserve on-disk executable casing in
 PathLookupHelper on Windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`PathLookupHelper.FindAllFullPathsFromPath` used to concatenate the
candidate command name with each `PATHEXT` entry and return that
synthesized path verbatim when the file existed. Because Windows
`PATHEXT` is typically registered uppercase (`.EXE`, `.CMD`, ...), an
on-disk `aspire.exe` would surface to user-facing output as
`aspire.EXE`, which looks like a different binary and breaks string-
compare dedup checks elsewhere in the install-discovery walk.

After matching the file by case-insensitive existence check, look up the
actual on-disk name via `Directory.EnumerateFileSystemEntries(directory,
fileName)` and return that spelling instead of the `PATHEXT`-derived
form. Linux and macOS are untouched.

The probe is guarded against `Directory.EnumerateFileSystemEntries`
throwing — if the lookup fails (permissions, path too long, etc.) the
helper falls back to the original PATHEXT-derived spelling, preserving
the prior behavior on the unhappy path.

Regression test added at
`tests/Aspire.Hosting.Tests/PathLookupHelperTests.cs` exercises the
Windows-only casing-preservation path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Shared/PathLookupHelper.cs                | 55 +++++++++++++++++--
 .../PathLookupHelperTests.cs                  | 25 +++++++++
 2 files changed, 76 insertions(+), 4 deletions(-)

diff --git a/src/Shared/PathLookupHelper.cs b/src/Shared/PathLookupHelper.cs
index bbcb10cc1f2..9036f1114ee 100644
--- a/src/Shared/PathLookupHelper.cs
+++ b/src/Shared/PathLookupHelper.cs
@@ -139,9 +139,9 @@ private static IEnumerable<string> FindAllFullPaths(string command, string? path
                 foreach (var extension in pathExtensions)
                 {
                     if (TryCombine(directory, command + extension, out var fullPathWithExt) &&
-                        FileExistsSafe(fileExists, fullPathWithExt))
+                        TryResolveExistingPath(fileExists, fullPathWithExt, out var existingPathWithExt))
                     {
-                        yield return fullPathWithExt;
+                        yield return existingPathWithExt;
                         foundExtensionMatch = true;
                         break;
                     }
@@ -155,9 +155,9 @@ private static IEnumerable<string> FindAllFullPaths(string command, string? path
 
             // Try exact match (for non-Windows, or as fallback on Windows if no extension match found in this directory).
             if (TryCombine(directory, command, out var fullPath) &&
-                FileExistsSafe(fileExists, fullPath))
+                TryResolveExistingPath(fileExists, fullPath, out var existingPath))
             {
-                yield return fullPath;
+                yield return existingPath;
             }
         }
     }
@@ -192,6 +192,53 @@ private static bool FileExistsSafe(Func<string, bool> fileExists, string path)
         }
     }
 
+    private static bool TryResolveExistingPath(Func<string, bool> fileExists, string path, [System.Diagnostics.CodeAnalysis.NotNullWhen(true)] out string? existingPath)
+    {
+        existingPath = null;
+        if (!FileExistsSafe(fileExists, path))
+        {
+            return false;
+        }
+
+        // Windows PATH probing appends PATHEXT entries such as ".EXE" even when
+        // the file is named "aspire.exe"; return the filesystem spelling so
+        // user-facing output doesn't inherit PATHEXT casing.
+        existingPath = TryGetActualPathCasing(path) ?? path;
+        return true;
+    }
+
+    private static string? TryGetActualPathCasing(string path)
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            return null;
+        }
+
+        var directory = Path.GetDirectoryName(path);
+        var fileName = Path.GetFileName(path);
+        if (string.IsNullOrEmpty(directory) || string.IsNullOrEmpty(fileName))
+        {
+            return null;
+        }
+
+        try
+        {
+            foreach (var entry in Directory.EnumerateFileSystemEntries(directory, fileName))
+            {
+                if (string.Equals(Path.GetFileName(entry), fileName, StringComparison.OrdinalIgnoreCase))
+                {
+                    return entry;
+                }
+            }
+        }
+        catch (Exception ex) when (ex is ArgumentException or DirectoryNotFoundException or IOException or NotSupportedException or PathTooLongException or UnauthorizedAccessException or System.Security.SecurityException)
+        {
+            return null;
+        }
+
+        return null;
+    }
+
     private static bool IsExplicitExecutablePath(string executablePath)
     {
         return !string.Equals(Path.GetFileName(executablePath), executablePath, StringComparison.Ordinal)
diff --git a/tests/Aspire.Hosting.Tests/PathLookupHelperTests.cs b/tests/Aspire.Hosting.Tests/PathLookupHelperTests.cs
index a9bf07567a6..1c9944fed77 100644
--- a/tests/Aspire.Hosting.Tests/PathLookupHelperTests.cs
+++ b/tests/Aspire.Hosting.Tests/PathLookupHelperTests.cs
@@ -268,6 +268,31 @@ public void FindAllFullPathsFromPath_WithPathExtensions_ReturnsOneMatchPerDirect
         Assert.Equal([firstExePath, secondCmdPath], result);
     }
 
+    [Fact]
+    public void FindAllFullPathsFromPath_WithPathExtensions_ReturnsFilesystemCasingOnWindows()
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            Assert.Skip("Windows filesystem casing is only observable on Windows.");
+            return;
+        }
+
+        using var tempDirectory = new TestTempDirectory();
+        var binPath = Path.Combine(tempDirectory.Path, "bin");
+        Directory.CreateDirectory(binPath);
+        var actualPath = Path.Combine(binPath, "aspire.exe");
+        File.WriteAllText(actualPath, string.Empty);
+
+        var result = PathLookupHelper.FindAllFullPathsFromPath(
+            "aspire",
+            binPath,
+            Path.PathSeparator,
+            File.Exists,
+            [".EXE"]);
+
+        Assert.Equal([actualPath], result);
+    }
+
     [Fact]
     public void FindFullPathFromPath_UsesCorrectPathSeparator()
     {

From 402388b08a7a5740f7093ff7634d9e14c85089c9 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 26 May 2026 19:09:21 -0400
Subject: [PATCH 03/15] feat(cli): add `aspire --info` to enumerate the running
 CLI's installs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Aspire CLI install enumeration was bolted onto `aspire doctor` alongside
the environment-prerequisite checks. That mixed two unrelated concerns
into one command, and there was no clean root-level surface for
"tell me what CLI I'm running and what other CLIs / hives this machine
has."

Add a root-level `--info` flag that returns the running CLI's identity
plus the install/orphan-hive table in one payload, and pull the install
table out of `aspire doctor`.

  - `aspire --info` — text: `Version`, `Channel`, then the per-row
    install block.
  - `aspire --info --format json` —
    `{ "version": ..., "channel": ..., "installs": [...] }`.
  - `aspire --info --self` — text: just the running CLI's row.
  - `aspire --info --self --format json` — single-element
    `InstallationInfo` array; this is the cross-version peer-probe
    contract consumed by `PeerInstallProbe.TryParseRichProbeResult`.

`--info` is wired as an `AsynchronousCommandLineAction` on a root-only
option, so `aspire --info` short-circuits routing the same way `--help`
and `--version` do — but unlike `--help`/`--version`, `--info` is
intentionally non-recursive: `aspire run --info` is a separate operation
(the `--info` token does not bind at subcommand scope, so `run` runs and
`--info` is ignored). This keeps install enumeration a deliberate
top-level concept and avoids the recursive-option / subcommand-local
`--format` shadowing trap, where `aspire run --info --format json` would
otherwise silently emit install text because `run`'s own `--format`
swallows the token.

`--self` and `--format` are hidden root-only options with validators
that fail parse when set without `--info`, so `aspire --self` and
`aspire --format json` produce a parse error instead of silently falling
through to grouped help (and `aspire doctor --format json` still routes
correctly to the doctor subcommand). `--info` is added to
`CommonOptionNames.InformationalOptionNames` so its text form does not
consume the first-run sentinel or start a tracked telemetry activity.

`aspire doctor` is now scoped to environment checks. The `installations`
field is removed from `aspire doctor --format json`; the `doctor --self`
hidden peer-probe variant is removed; the install-table rendering and
the install-related `DoctorCommandStrings` resource entries (and
matching xlf entries across 13 languages) are deleted.

`PeerInstallProbe` now spawns peers with
`["--info", "--self", "--format", "json"]`. An older peer that predates
`--info` exits non-zero on the unknown option; the probe falls through
to a second spawn of `["--version"]` and re-derives the peer's channel
from its InformationalVersion string for PR builds (the existing
`--version` fallback path in the probe). No explicit shim for the old
`doctor --self` argv is needed because no live consumer of that argv
remains.

Why this approach
-----------------

`CliExecutionContext`'s DI factory used to eagerly call
`IIdentityChannelReader.ReadChannel()`, which throws when a CLI binary
has missing or invalid `AspireCliChannel` assembly metadata. That made
the channel-failure path undeliverable for any diagnostic surface: the
factory would crash before any subcommand or root-option action ran.
The factory now wraps the read in `Lazy<string>` and
`CliExecutionContext.IdentityChannel` returns
`_lazy?.Value ?? identityChannel`, preserving the original throwing
semantics on first access for consumers that actually need the channel
(packaging, scaffolding, update / new / init), while letting
`InfoOptionAction` inject `IIdentityChannelReader` directly and catch
the exception itself — exit 0, channel field dropped from JSON (via
`DefaultIgnoreCondition.WhenWritingNull`), Channel row omitted from text.

`InfoOption`, `InfoSelfOption`, and `InfoFormatOption` are per-
`RootCommand` instance fields rather than `static`. Each `RootCommand`
construction sets `InfoOption.Action` and adds option validators; with
static fields, concurrent tests building their own `RootCommand` would
race on the shared `Action` setter (last write wins, the test that
built first sees another test's service provider) and `Validators.Add`
would accumulate across instances.

`WingetFirstRunProbe.Run` moves from `BundleService` + the old install
table call site into the `CliExecutionContext` DI factory in
`Program.cs`. Same behavior, single call site, fires before the
install-source sidecar is read by any downstream consumer;
`BundleService` is now install-source-agnostic.

Surprises and call-outs
-----------------------

- `--info` is intentionally root-only. `aspire --info` fires install
  enumeration; `aspire run --info` is a separate operation that runs
  the subcommand and ignores the unmatched `--info` token. Two
  regression tests (`Info_OnSubcommand_DoesNotFireInfoAction`,
  `Info_OnSubcommand_WithFormat_BindsFormatToSubcommand`) pin this so
  a future Recursive flip can't silently resurrect the subcommand-local
  `--format` shadowing trap.

- Discovery-walk failure exits 0, not non-zero. `BuildRowsSafelyAsync`
  catches a throwing `IInstallationDiscovery.DiscoverAllAsync`
  (filesystem ACL, IO on `~/.aspire/hives`, ...) and emits a single
  failure row (`kind: "discovery-failed"`, `status: "failed"`,
  `statusReason: <message>`) so `aspire --info` stays useful for
  diagnosing a flaky environment. Same posture as the channel-read and
  self-version tolerant paths. The empty-installs case still emits
  `"installs": []` rather than dropping the field.

- Channel-read failure also deliberately does not exit non-zero. The
  `--info` surface is exactly the one a user reaches for to find out
  their binary is broken; it would be self-defeating to crash.

- `--format list` is accepted as the explicit spelling of the default
  text rendering. The enum stays `{ List, Json }` so the
  System.CommandLine value parser rejects unknown values like `table`.

- The `--info --self --format json` row uses the `InstallationInfo`
  field set (`path`, `canonicalPath`, `version`, `channel`, `source`,
  `pathStatus`, `status`, `statusReason`), which is *distinct from* the
  aggregate `installs[*]` row shape (`id`, `kind`, `channel`, `path`,
  `hive`, `status`, `statusReason`, `managedBy`). Both shapes are
  documented in `docs/specs/cli-output-formats.md`.

Tests
-----

`InfoOptionTests.cs` covers: peer-probe contract roundtrip, channel-read
failure path (asserts `CliExecutionContext` still resolves and the
command exits 0), `channel: "local"` is not treated as failure,
empty-installs `installs: []`, discovery-walk failure exits 0 with a
`discovery-failed` row, `--format list` synonym + `--format table`
rejection, `aspire run --info` is non-recursive and does not fire the
info action, parse errors for `--self`/`--format` without `--info`, the
`aspire doctor --format json` regression guard, and an end-to-end
peer-probe roundtrip that feeds `--info --self --format json` output
through `InstallationInfoParser.Parse`.

`PeerInstallProbeTests` argv assertion, shell/batch fake scripts
(`EmitExit`, `StderrRepeatScript`, `DoctorOrVersionScript`), and inline
comments updated to dispatch on `--info` instead of `doctor --self`.
New tests: `HiveEnumeratorTests` (channel-shape allow-list + path
returns), `WindowsRegistryReaderTests` (Windows-only HKCU round-trip
with prefixed entries swept on each run), `WingetStartupProbeTests`
(pins the DI-factory invocation contract and the swallow-on-failure
behavior).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/specs/cli-output-formats.md              |  51 ++
 .../{install-routes.md => install-sources.md} |  34 +-
 src/Aspire.Cli/Acquisition/HiveEnumerator.cs  |  67 ++
 .../Acquisition/PeerInstallProbe.cs           |  12 +-
 src/Aspire.Cli/Bundles/BundleService.cs       |  18 +-
 src/Aspire.Cli/CliExecutionContext.cs         |  33 +-
 src/Aspire.Cli/Commands/DoctorCommand.cs      |  47 +-
 src/Aspire.Cli/Commands/InfoOptionAction.cs   | 221 ++++++
 .../Commands/InstallationInfoOutput.cs        | 315 +++++---
 src/Aspire.Cli/Commands/RootCommand.cs        | 102 ++-
 src/Aspire.Cli/CommonOptionNames.cs           |  10 +-
 src/Aspire.Cli/JsonSourceGenerationContext.cs |   3 +
 src/Aspire.Cli/Program.cs                     |  83 +-
 .../DoctorCommandStrings.Designer.cs          | 117 ---
 .../Resources/DoctorCommandStrings.resx       |  46 --
 .../Resources/RootCommandStrings.Designer.cs  |  27 +
 .../Resources/RootCommandStrings.resx         |   9 +
 .../Resources/xlf/DoctorCommandStrings.cs.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.de.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.es.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.fr.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.it.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.ja.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.ko.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.pl.xlf |  65 --
 .../xlf/DoctorCommandStrings.pt-BR.xlf        |  65 --
 .../Resources/xlf/DoctorCommandStrings.ru.xlf |  65 --
 .../Resources/xlf/DoctorCommandStrings.tr.xlf |  65 --
 .../xlf/DoctorCommandStrings.zh-Hans.xlf      |  65 --
 .../xlf/DoctorCommandStrings.zh-Hant.xlf      |  65 --
 .../Resources/xlf/RootCommandStrings.cs.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.de.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.es.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.fr.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.it.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.ja.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.ko.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.pl.xlf   |  15 +
 .../xlf/RootCommandStrings.pt-BR.xlf          |  15 +
 .../Resources/xlf/RootCommandStrings.ru.xlf   |  15 +
 .../Resources/xlf/RootCommandStrings.tr.xlf   |  15 +
 .../xlf/RootCommandStrings.zh-Hans.xlf        |  15 +
 .../xlf/RootCommandStrings.zh-Hant.xlf        |  15 +
 .../EnvironmentCheckResult.cs                 |   7 -
 .../Acquisition/HiveEnumeratorTests.cs        |  95 +++
 .../Acquisition/PeerInstallProbeTests.cs      |  75 +-
 .../Acquisition/WindowsRegistryReaderTests.cs | 264 ++++++
 .../Acquisition/WingetStartupProbeTests.cs    | 128 +++
 .../Commands/DoctorCommandTests.cs            | 263 +-----
 .../Commands/InfoOptionTests.cs               | 750 ++++++++++++++++++
 .../Commands/SetupCommandTests.cs             |  12 +-
 ...asedAppHostServerChannelResolutionTests.cs |   2 +-
 .../Packaging/TemporaryNuGetConfigTests.cs    |   2 +-
 tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs |   2 +
 54 files changed, 2355 insertions(+), 1480 deletions(-)
 rename docs/specs/{install-routes.md => install-sources.md} (59%)
 create mode 100644 src/Aspire.Cli/Acquisition/HiveEnumerator.cs
 create mode 100644 src/Aspire.Cli/Commands/InfoOptionAction.cs
 create mode 100644 tests/Aspire.Cli.Tests/Acquisition/HiveEnumeratorTests.cs
 create mode 100644 tests/Aspire.Cli.Tests/Acquisition/WindowsRegistryReaderTests.cs
 create mode 100644 tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs
 create mode 100644 tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs

diff --git a/docs/specs/cli-output-formats.md b/docs/specs/cli-output-formats.md
index bbe2393303a..e5bad47a867 100644
--- a/docs/specs/cli-output-formats.md
+++ b/docs/specs/cli-output-formats.md
@@ -474,6 +474,57 @@ The JSON form includes secret values. Do not redirect it to logs or files unless
 
 `status` is one of `pass`, `warning`, or `fail`. Individual checks can include `details`, `fix`, `link`, or command-specific `metadata`.
 
+### `aspire --info`
+
+`aspire --info --format json` emits a JSON object combining the running CLI's version, its identity channel, and the list of Aspire CLI installs and orphan package hives that the running CLI can discover:
+
+```json
+{
+  "version": "13.2.0",
+  "channel": "stable",
+  "installs": [
+    {
+      "id": "script",
+      "kind": "script",
+      "channel": "stable",
+      "path": "/home/user/.aspire/bin/aspire",
+      "hive": "/home/user/.aspire/hives/stable",
+      "status": "active"
+    },
+    {
+      "id": "pr-17400",
+      "kind": "orphan-hive",
+      "channel": "pr-17400",
+      "hive": "/home/user/.aspire/hives/pr-17400",
+      "status": "no install found",
+      "statusReason": "No discovered install reports this hive's channel."
+    },
+    {
+      "id": "stable",
+      "kind": "homebrew",
+      "channel": "stable",
+      "path": "/opt/homebrew/Caskroom/aspire/13.2.0/aspire",
+      "status": "active",
+      "managedBy": "homebrew"
+    },
+    {
+      "id": "pr-17500",
+      "kind": "pr",
+      "channel": "pr-17500",
+      "path": "/home/user/.aspire/dogfood/pr-17500/bin/aspire",
+      "status": "failed",
+      "statusReason": "Peer probe exited with code 137 (SIGKILL)."
+    }
+  ]
+}
+```
+
+`installs[*].status` uses the install-discovery status (`active`, `shadowed`, `notOnPath`, `failed`, `notProbed`) or `no install found` for orphan hives. When the row has a human-readable reason (failed probes, orphan hives), it rides on the separate `statusReason` field — the `status` value itself stays enum-shaped so programmatic consumers can `switch` on it.
+
+The top-level `channel` is the running CLI's identity (`local`, `stable`, `staging`, `daily`, or `pr-<N>`). It is omitted from the JSON output when the running binary has missing or invalid `AspireCliChannel` assembly metadata; the command still exits 0 so users can use `aspire --info` to diagnose a broken binary. The `installs` array is always present, possibly empty.
+
+`aspire --info --self --format json` is a hidden modifier used by the install-discovery peer-probe path so a newer CLI can ask a peer CLI to describe itself. Its output is a single-element array whose row carries the running CLI's own install metadata — `path`, `canonicalPath`, `version`, `channel`, `source`, `pathStatus`, `status`, and `statusReason`. That row shape is *distinct from* the `installs[*]` rows above: it has neither the `id`/`kind`/`hive`/`managedBy` aggregate-table fields nor the per-row sort projection. It is the internal cross-version contract between Aspire CLI builds and is not a stable surface for external tooling; it may change without notice.
+
 ### `aspire config info`
 
 `aspire config info --json` is a hidden tooling command that emits configuration paths, feature metadata, settings schemas, and advertised CLI capabilities:
diff --git a/docs/specs/install-routes.md b/docs/specs/install-sources.md
similarity index 59%
rename from docs/specs/install-routes.md
rename to docs/specs/install-sources.md
index d2b8f2c8c72..c37d9d7c0b0 100644
--- a/docs/specs/install-routes.md
+++ b/docs/specs/install-sources.md
@@ -1,8 +1,8 @@
-# Aspire CLI install-route sidecar
+# Aspire CLI install-source sidecar
 
 > Pairs with `docs/specs/bundle.md` (bundle extraction layout) and `docs/ci/native-cli-packaging.md` (how archives are produced).
 
-The CLI binary identifies its install route by reading a single
+The CLI binary identifies its install source by reading a single
 `.aspire-install.json` sidecar that lives next to the binary. The sidecar's
 `source` field selects the extract-dir shape used by `BundleService` and, for
 portable installs, the Aspire home used for hives and local state.
@@ -13,10 +13,10 @@ portable installs, the Aspire home used for hives and local state.
 (`<binaryDir>/.aspire-install.json`) and contains exactly one field:
 
 ```json
-{ "source": "<route>" }
+{ "source": "<source>" }
 ```
 
-| `source` value | Install route                                          |
+| `source` value | Install source                                          |
 |----------------|--------------------------------------------------------|
 | `brew`         | Homebrew cask                                          |
 | `winget`       | WinGet portable manifest                               |
@@ -37,26 +37,26 @@ install. `script` and `localhive` use the parent of `bin`; `pr` uses the parent
 of `dogfood/pr-<N>/bin`. Package-manager installs and sidecar-less binaries keep
 the default Aspire home (`ASPIRE_HOME` when set, otherwise `$HOME/.aspire`).
 
-## Per-route authorship
+## Per-source authorship
 
-**The shared per-RID CLI archives (`aspire-cli-<rid>-*.zip` / `.tar.gz`) ship sidecar-free.** Those archives are reused across brew, winget, the release script, and the PR script — none of them owns the route label. Each route writes its own sidecar at install time.
+**The shared per-RID CLI archives (`aspire-cli-<rid>-*.zip` / `.tar.gz`) ship sidecar-free.** Those archives are reused across Homebrew, WinGet, the release script, and the PR script — none of them owns the source label. Each source writes its own sidecar at install time.
 
-| Route       | Archive shape                          | Sidecar writer                                                      |
+| Source       | Archive shape                          | Sidecar writer                                                      |
 |-------------|----------------------------------------|---------------------------------------------------------------------|
-| brew        | shared per-RID tarball                 | cask `postflight` block in `eng/homebrew/aspire.rb.template`        |
+| Homebrew    | shared per-RID tarball                 | cask `postflight` block in `eng/homebrew/aspire.rb.template`        |
 | winget      | shared per-RID zip                     | CLI first-run probe (`WingetFirstRunProbe`) — uses the WinGet portable ARP registry entry to confirm the running binary was placed by winget, then stamps the sidecar |
 | script      | shared per-RID archive                 | `eng/scripts/get-aspire-cli.{sh,ps1}` (post-extraction)             |
 | PR script   | shared per-RID archive                 | `eng/scripts/get-aspire-cli-pr.{sh,ps1}` (post-extraction)          |
-| dotnet-tool | route-exclusive nupkg                  | payload-embedded (staged by `Aspire.Cli.csproj` `_PreparePreBuiltCliBinaryForPackTool`) |
-| localhive   | local-only (no shared archive)         | `localhive.{sh,ps1}` writes the sidecar after copying the CLI binary into `<prefix>/bin/`. When `--output PATH` is used, the sidecar is written inside the output dir, which is appropriate because localhive archives are route-exclusive (only consumed as localhive installs). |
+| dotnet-tool | source-exclusive nupkg                  | payload-embedded (staged by `Aspire.Cli.csproj` `_PreparePreBuiltCliBinaryForPackTool`) |
+| localhive   | local-only (no shared archive)         | `localhive.{sh,ps1}` writes the sidecar after copying the CLI binary into `<prefix>/bin/`. When `--output PATH` is used, the sidecar is written inside the output dir, which is appropriate because localhive archives are source-exclusive (only consumed as localhive installs). |
 
-The dotnet-tool nupkg is the one exception that payload-embeds the sidecar: the nupkg is route-exclusive (only `dotnet tool install` consumes it), so the embedded sidecar cannot leak into another route's prefix.
+The dotnet-tool nupkg is the one exception that payload-embeds the sidecar: the nupkg is source-exclusive (only `dotnet tool install` consumes it), so the embedded sidecar cannot leak into another source's prefix.
 
 ## Why no payload-embed in shared archives
 
-Until PR 16817 the per-RID archives baked `{"source":"brew"}` (osx-*) and `{"source":"winget"}` (win-*) into the archive root via an MSBuild target. Because the osx-* tarball is also consumed by `get-aspire-cli-pr.sh`, the smuggled `brew` sidecar landed in the script-route prefix at `<prefix>/dogfood/pr-<N>/bin/.aspire-install.json`, and `BundleService` then selected `binaryDir` (the `brew` flat-layout case) as the extract dir — producing `<prefix>/dogfood/pr-<N>/bin/versions/<v>/` instead of `<prefix>/dogfood/pr-<N>/versions/<v>/`.
+Until PR 16817 the per-RID archives baked source sidecars (`osx-*` as Homebrew, `win-*` as WinGet) into the archive root via an MSBuild target. Because the `osx-*` tarball is also consumed by `get-aspire-cli-pr.sh`, the smuggled `brew` sidecar landed in the script-source prefix at `<prefix>/dogfood/pr-<N>/bin/.aspire-install.json`, and `BundleService` then selected `binaryDir` (the `brew` flat-layout case) as the extract dir — producing `<prefix>/dogfood/pr-<N>/bin/versions/<v>/` instead of `<prefix>/dogfood/pr-<N>/versions/<v>/`.
 
-Removing the MSBuild target and moving each route to author its own sidecar at install time makes the per-RID archive route-agnostic and prevents the leak by construction.
+Removing the MSBuild target and moving each source to author its own sidecar at install time makes the per-RID archive source-agnostic and prevents the leak by construction.
 
 ## Producer-side invariants (build / CI)
 
@@ -67,10 +67,10 @@ Two mechanical checks guard the contract:
 
 ## Reader-side invariants (runtime)
 
-`BundleService.ComputeDefaultExtractDir` is the single point of truth for layout selection. It performs no path-shape detection: layout is a pure function of the sidecar `source` value (or the fallback when the sidecar is absent, unreadable, malformed, or has an unknown `source`). Unknown `source` values fall back to the default Aspire home so unrecognized installs do not try to write next to the CLI binary. Coverage lives in `tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossRouteExtractionTests.cs` as a theory over (source × prefix-shape) rows, including the cross-route case where a `brew` sidecar lands under a script-style prefix.
+`BundleService.ComputeDefaultExtractDir` is the single point of truth for layout selection. It performs no path-shape detection: layout is a pure function of the sidecar `source` value (or the fallback when the sidecar is absent, unreadable, malformed, or has an unknown `source`). Unknown `source` values fall back to the default Aspire home so unrecognized installs do not try to write next to the CLI binary. Coverage lives in `tests/Aspire.Cli.Tests/Bundles/BundleServiceCrossSourceExtractionTests.cs` as a theory over (source × prefix-shape) rows, including the cross-source case where a `brew` sidecar lands under a script-style prefix.
 
-`CliPathHelper.GetAspireHomeDirectory` is the single point of truth for Aspire-home selection. It reads the same sidecar but only changes home for Aspire-owned portable routes (`script`, `pr`, and `localhive`); package-manager routes use the user-profile home because their install roots are package-manager-owned. Coverage lives in `tests/Aspire.Cli.Tests/Utils/CliPathHelperTests.cs`.
+`CliPathHelper.GetAspireHomeDirectory` is the single point of truth for Aspire-home selection. It reads the same sidecar but only changes home for Aspire-owned portable sources (`script`, `pr`, and `localhive`); package-manager sources use the user-profile home because their install roots are package-manager-owned. Coverage lives in `tests/Aspire.Cli.Tests/Utils/CliPathHelperTests.cs`.
 
-> **Discovery scope (dotnet-tool route).** Install discovery walks the default `dotnet tool install -g` location at `~/.dotnet/tools/.store/aspire.cli` only. Custom `--tool-path` installs are not discovered today: the dotnet CLI has no machine-wide registry of arbitrary `--tool-path` installs to enumerate, and walking the filesystem would balloon the cost of `aspire doctor`. Users with a custom-`--tool-path` install can confirm it directly with `<tool-path>/aspire doctor --self`.
+> **Discovery scope (dotnet-tool source).** Install discovery walks the default `dotnet tool install -g` location at `~/.dotnet/tools/.store/aspire.cli` only. Custom `--tool-path` installs are not discovered today: the dotnet CLI has no machine-wide registry of arbitrary `--tool-path` installs to enumerate, and walking the filesystem would balloon the cost of `aspire --info`. Users with a custom-`--tool-path` install can confirm it directly with `<tool-path>/aspire --info --self`.
 
-For read-only install discovery (`aspire doctor --format json`), sidecar existence is the trust signal for peer probing. A candidate with any readable sidecar is probed even when `source` is not in the known route table; the raw `source` string is surfaced as the installation `route` so future package-manager routes can appear before this consumer updates. Sidecar-less, unreadable, or malformed candidates are listed without executing the binary.
+For read-only install discovery (`aspire --info --format json`), sidecar existence is the trust signal for peer probing. A candidate with any readable sidecar is probed even when `source` is not in the known source table; the raw `source` string is surfaced as the installation `source` so future package-manager sources can appear before this consumer updates. Sidecar-less, unreadable, or malformed candidates are listed without executing the binary.
diff --git a/src/Aspire.Cli/Acquisition/HiveEnumerator.cs b/src/Aspire.Cli/Acquisition/HiveEnumerator.cs
new file mode 100644
index 00000000000..4401175e23e
--- /dev/null
+++ b/src/Aspire.Cli/Acquisition/HiveEnumerator.cs
@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Aspire.Cli.Acquisition;
+
+/// <summary>
+/// Read-only enumeration of Aspire CLI package hives under
+/// <c>$HOME/.aspire/hives/&lt;channel&gt;</c>. Hives are populated by install
+/// scripts and read by <c>aspire --info</c> to surface orphan hives.
+/// </summary>
+/// <remarks>
+/// Channel-keyed lookups (<see cref="HasHive"/>, <see cref="GetHivePath"/>)
+/// only accept the channel shapes that the build pipeline ever bakes — see
+/// <see cref="IdentityChannelReader.IsValidChannel(string)"/>. Channels can
+/// reach this type via peer <c>--info --self</c> output (untrusted JSON
+/// from a sibling CLI binary), so any value outside that allow-list is
+/// treated as "no hive": it prevents directory-separator / <c>..</c> /
+/// invalid-character inputs from being fed to <c>Path.Combine</c> +
+/// <see cref="DirectoryInfo"/>, which would otherwise either escape the
+/// hives root in the displayed path or throw on the <see cref="DirectoryInfo"/>
+/// constructor.
+/// </remarks>
+internal sealed class HiveEnumerator(CliExecutionContext executionContext)
+{
+    public IReadOnlyList<HiveInfo> GetHives()
+    {
+        if (!executionContext.HivesDirectory.Exists)
+        {
+            return [];
+        }
+
+        return executionContext.HivesDirectory
+            .EnumerateDirectories()
+            .OrderBy(d => d.Name, StringComparer.Ordinal)
+            .Select(d => new HiveInfo(d.Name, d.FullName))
+            .ToList();
+    }
+
+    /// <summary>
+    /// Returns the on-disk path of the hive for <paramref name="channel"/>,
+    /// or <see langword="null"/> when <paramref name="channel"/> is not a
+    /// recognized channel shape. Returning a path here makes no claim about
+    /// whether the directory exists — use <see cref="HasHive"/> for that.
+    /// </summary>
+    public string? GetHivePath(string channel)
+        => TryGetHiveDirectory(channel) is { } dir ? dir.FullName : null;
+
+    /// <summary>
+    /// Returns <see langword="true"/> when <paramref name="channel"/> is a
+    /// recognized channel shape and the corresponding hive directory exists.
+    /// Unrecognized channel shapes always return <see langword="false"/>.
+    /// </summary>
+    public bool HasHive(string channel)
+        => TryGetHiveDirectory(channel) is { Exists: true };
+
+    private DirectoryInfo? TryGetHiveDirectory(string channel)
+    {
+        if (!IdentityChannelReader.IsValidChannel(channel))
+        {
+            return null;
+        }
+
+        return new DirectoryInfo(Path.Combine(executionContext.HivesDirectory.FullName, channel));
+    }
+}
+
+internal sealed record HiveInfo(string Name, string Path);
diff --git a/src/Aspire.Cli/Acquisition/PeerInstallProbe.cs b/src/Aspire.Cli/Acquisition/PeerInstallProbe.cs
index c242e100cbc..ce25d159a2d 100644
--- a/src/Aspire.Cli/Acquisition/PeerInstallProbe.cs
+++ b/src/Aspire.Cli/Acquisition/PeerInstallProbe.cs
@@ -12,7 +12,7 @@ namespace Aspire.Cli.Acquisition;
 
 /// <summary>
 /// Default <see cref="IPeerInstallProbe"/>. Spawns the peer with
-/// <c>doctor --self --format json</c>, enforces a hard timeout, captures stdout
+/// <c>--info --self --format json</c>, enforces a hard timeout, captures stdout
 /// up to a byte cap, and kills the entire process tree on timeout so a
 /// hung peer cannot survive past the parent's lifetime.
 /// </summary>
@@ -71,14 +71,14 @@ public async Task<PeerProbeResult> ProbeAsync(string binaryPath, CancellationTok
             return new PeerProbeResult.Failed("Binary not found.");
         }
 
-        // Primary path: ask the peer to self-describe via `doctor --self --format json`.
+        // Primary path: ask the peer to self-describe via `--info --self --format json`.
         // `--self` is required: without it the peer would run a full discovery
         // walk and probe back into us (and into every other peer it finds),
         // turning a single discovery invocation into a recursive fan-out
         // bounded only by the per-level timeout. `--format json` is
         // required so the peer emits a machine-readable row (the human
         // table layout is the default when `--format` is omitted).
-        var primary = await SpawnAndCaptureAsync(binaryPath, ["doctor", "--self", "--format", "json"], cancellationToken).ConfigureAwait(false);
+        var primary = await SpawnAndCaptureAsync(binaryPath, ["--info", "--self", "--format", "json"], cancellationToken).ConfigureAwait(false);
         if (primary.Cancelled)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -95,11 +95,11 @@ public async Task<PeerProbeResult> ProbeAsync(string binaryPath, CancellationTok
         }
 
         // Fallback path. We reach here for:
-        //   - peer exited non-zero (common: peer predates `doctor --self`
+        //   - peer exited non-zero (common: peer predates `--info --self`
         //     and System.CommandLine rejected the unknown option),
         //   - peer emitted blank/whitespace-only stdout,
         //   - peer emitted JSON we couldn't parse as the expected rich shape.
-        // Older peers without `doctor --self` can't report their channel
+        // Older peers without `--info --self` can't report their channel
         // here, but `InstallationDiscovery` recovers `pr-<N>` from the
         // reported informational version string so the user-facing table
         // still shows the channel for PR builds.
@@ -128,7 +128,7 @@ public async Task<PeerProbeResult> ProbeAsync(string binaryPath, CancellationTok
             return new PeerProbeResult.Failed(DescribePrimaryFailure(primary, alsoTriedVersion: true));
         }
 
-        // Partial install details: version only. Route is overlaid by InstallationDiscovery
+        // Partial install details: version only. Source is overlaid by InstallationDiscovery
         // from the locally-readable sidecar. Channel intentionally null — we can't
         // read assembly metadata
         // from outside an AOT binary, and the older peer has no surface that
diff --git a/src/Aspire.Cli/Bundles/BundleService.cs b/src/Aspire.Cli/Bundles/BundleService.cs
index 08464297689..6ec80751c37 100644
--- a/src/Aspire.Cli/Bundles/BundleService.cs
+++ b/src/Aspire.Cli/Bundles/BundleService.cs
@@ -21,8 +21,7 @@ namespace Aspire.Cli.Bundles;
 internal sealed class BundleService(
     IBundlePayloadProvider payloadProvider,
     ILayoutDiscovery layoutDiscovery,
-    ILogger<BundleService> logger,
-    WingetFirstRunProbe? wingetFirstRunProbe = null) : IBundleService
+    ILogger<BundleService> logger) : IBundleService
 {
     /// <summary>
     /// Name of the marker file written after successful extraction.
@@ -192,19 +191,6 @@ private async Task<BundleExtractResult> ExtractAsyncCore(string destinationPath,
             return null;
         }
 
-        // The winget portable installer has no post-install hook, so the CLI
-        // self-stamps the install-route sidecar on first run. No-op on
-        // non-Windows and once the sidecar already exists.
-        if (wingetFirstRunProbe is not null && OperatingSystem.IsWindows())
-        {
-            var realBinaryPath = CliPathHelper.ResolveSymlinkOrOriginalPath(processPath, logger);
-            var binaryDir = Path.GetDirectoryName(realBinaryPath);
-            if (!string.IsNullOrEmpty(binaryDir))
-            {
-                wingetFirstRunProbe.Run(binaryDir);
-            }
-        }
-
         var extractDir = GetDefaultExtractDir(processPath);
         if (string.IsNullOrEmpty(extractDir))
         {
@@ -382,7 +368,7 @@ private async Task<bool> ExtractVersionedLayoutAsync(
 
     /// <summary>
     /// Computes the bundle extract directory from the sidecar source value.
-    /// See <c>docs/specs/install-routes.md</c> for the contract.
+    /// See <c>docs/specs/install-sources.md</c> for the contract.
     /// </summary>
     internal static string? ComputeDefaultExtractDir(string processPath)
         => ComputeDefaultExtractDir(processPath, logger: null);
diff --git a/src/Aspire.Cli/CliExecutionContext.cs b/src/Aspire.Cli/CliExecutionContext.cs
index 05585b040f9..1050dc3117a 100644
--- a/src/Aspire.Cli/CliExecutionContext.cs
+++ b/src/Aspire.Cli/CliExecutionContext.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using Aspire.Cli.Acquisition;
 
 namespace Aspire.Cli;
 
@@ -35,8 +36,28 @@ internal sealed class CliExecutionContext(DirectoryInfo workingDirectory, Direct
     /// CI bakes <c>pr-&lt;PR_NUMBER&gt;</c> directly for PR builds, so no
     /// runtime "<c>pr</c> + parsed PrNumber" join is required.
     /// </para>
+    /// <para>
+    /// When <see cref="IdentityChannelLazy"/> is set (the production path), the
+    /// underlying <see cref="IIdentityChannelReader.ReadChannel"/> call is
+    /// deferred to first access of this property. That keeps the
+    /// <see cref="CliExecutionContext"/> DI factory resilient: a CLI binary
+    /// with missing/invalid <c>AspireCliChannel</c> assembly metadata can still
+    /// resolve the context (so diagnostic paths like <c>aspire --info</c> can
+    /// render), and only consumers that actually need the channel pay the
+    /// throw cost. Direct callers that pass the constructor-supplied
+    /// identity-channel string keep the eager string semantics.
+    /// </para>
     /// </remarks>
-    public string IdentityChannel { get; } = identityChannel;
+    public string IdentityChannel => IdentityChannelLazy is { } lazy ? lazy.Value : identityChannel;
+
+    /// <summary>
+    /// Optional lazy source for <see cref="IdentityChannel"/>. When non-null,
+    /// the <see cref="IdentityChannel"/> getter forwards to <c>lazy.Value</c>
+    /// instead of returning the constructor-supplied identity-channel string.
+    /// Set by the production DI factory in <c>Program.cs</c> to defer
+    /// <see cref="IIdentityChannelReader.ReadChannel"/> until first use.
+    /// </summary>
+    internal Lazy<string>? IdentityChannelLazy { get; init; }
 
     /// <summary>
     /// Gets the directory where restored NuGet packages are cached for apphost server sessions.
@@ -63,17 +84,17 @@ internal sealed class CliExecutionContext(DirectoryInfo workingDirectory, Direct
     public DirectoryInfo HomeDirectory { get; } = homeDirectory ?? new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));
 
     /// <summary>
-    /// Gets the Aspire state root used for route-specific install layouts.
+    /// Gets the Aspire state root used for source-specific install layouts.
     /// </summary>
     /// <remarks>
-    /// Production wires this explicitly via <see cref="Program.BuildCliExecutionContext"/>
+    /// Production wires this explicitly via <see cref="Program.BuildCliExecutionContext(bool, string, string, string, string?)"/>
     /// using <see cref="Utils.CliPathHelper.GetAspireHomeDirectory(string?, Microsoft.Extensions.Logging.ILogger?)"/>
-    /// so the install-route sidecar lookup runs. When neither <c>aspireHomeDirectory</c>
+    /// so the install-source sidecar lookup runs. When neither <c>aspireHomeDirectory</c>
     /// nor <c>homeDirectory</c> are supplied (direct construction in tests), the same
-    /// install-route lookup is performed here so route-aware code paths see a
+    /// install-source lookup is performed here so source-aware code paths see a
     /// consistent value. When <c>homeDirectory</c> is supplied without
     /// <c>aspireHomeDirectory</c>, the home stays contained within the test directory
-    /// at <c>&lt;homeDirectory&gt;/.aspire</c> — the install-route lookup is
+    /// at <c>&lt;homeDirectory&gt;/.aspire</c> — the install-source lookup is
     /// intentionally skipped because tests passing an explicit <c>homeDirectory</c>
     /// are declaring their own filesystem sandbox.
     /// </remarks>
diff --git a/src/Aspire.Cli/Commands/DoctorCommand.cs b/src/Aspire.Cli/Commands/DoctorCommand.cs
index aa546e943ff..9c61088a95e 100644
--- a/src/Aspire.Cli/Commands/DoctorCommand.cs
+++ b/src/Aspire.Cli/Commands/DoctorCommand.cs
@@ -3,14 +3,12 @@
 
 using System.CommandLine;
 using System.Globalization;
-using Aspire.Cli.Acquisition;
 using Aspire.Cli.Configuration;
 using Aspire.Cli.Interaction;
 using Aspire.Cli.Resources;
 using Aspire.Cli.Utils;
 using Aspire.Cli.Telemetry;
 using Aspire.Cli.Utils.EnvironmentChecker;
-using Microsoft.Extensions.Logging;
 using Spectre.Console;
 
 namespace Aspire.Cli.Commands;
@@ -26,76 +24,44 @@ internal sealed class DoctorCommand : BaseCommand
     // already used by other --format json commands (ApiGet, ApiList, DocsSearch, DocsList).
 
     private readonly IEnvironmentChecker _environmentChecker;
-    private readonly IInstallationDiscovery _installationDiscovery;
-    private readonly WingetFirstRunProbe _wingetFirstRunProbe;
     private readonly IAnsiConsole _ansiConsole;
-    private readonly ILogger<DoctorCommand> _logger;
     private static readonly Option<OutputFormat> s_formatOption = new("--format")
     {
         Description = DoctorCommandStrings.JsonOptionDescription
     };
-    private static readonly Option<bool> s_selfOption = new("--self")
-    {
-        Hidden = true,
-    };
 
     public DoctorCommand(
         IEnvironmentChecker environmentChecker,
-        IInstallationDiscovery installationDiscovery,
-        WingetFirstRunProbe wingetFirstRunProbe,
         IFeatures features,
         ICliUpdateNotifier updateNotifier,
         CliExecutionContext executionContext,
         IInteractionService interactionService,
         IAnsiConsole ansiConsole,
-        ILogger<DoctorCommand> logger,
         AspireCliTelemetry telemetry)
         : base("doctor", DoctorCommandStrings.Description, features, updateNotifier, executionContext, interactionService, telemetry)
     {
         _environmentChecker = environmentChecker;
-        _installationDiscovery = installationDiscovery;
-        _wingetFirstRunProbe = wingetFirstRunProbe;
         _ansiConsole = ansiConsole;
-        _logger = logger;
 
         Options.Add(s_formatOption);
-        Options.Add(s_selfOption);
     }
 
     protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
     {
         var format = parseResult.GetValue(s_formatOption);
-        var selfOnly = parseResult.GetValue(s_selfOption);
-
-        if (selfOnly)
-        {
-            var self = InstallationInfoOutput.DescribeSelfSafely(_installationDiscovery, _logger);
-            if (format == OutputFormat.Json)
-            {
-                OutputJson([], self);
-            }
-            else
-            {
-                InstallationInfoOutput.OutputTable(_ansiConsole, self);
-            }
-            return CommandResult.Success();
-        }
-
-        var installationsTask = InstallationInfoOutput.DiscoverAllSafelyAsync(_installationDiscovery, _wingetFirstRunProbe, _logger, cancellationToken);
 
         // Run all prerequisite checks
         var results = await InteractionService.ShowStatusAsync(
             DoctorCommandStrings.CheckingPrerequisites,
             async () => await _environmentChecker.CheckAllAsync(cancellationToken));
-        var installations = await installationsTask;
 
         if (format == OutputFormat.Json)
         {
-            OutputJson(results, installations);
+            OutputJson(results);
         }
         else
         {
-            OutputHumanReadable(results, installations);
+            OutputHumanReadable(results);
         }
 
         // Exit code: 0 if no failures (warnings are OK), 1 (InvalidCommand) if any failures
@@ -103,7 +69,7 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
         return CommandResult.FromExitCode(hasFailures ? CliExitCodes.InvalidCommand : CliExitCodes.Success);
     }
 
-    private void OutputJson(IReadOnlyList<EnvironmentCheckResult> results, IReadOnlyList<InstallationInfo> installations)
+    private void OutputJson(IReadOnlyList<EnvironmentCheckResult> results)
     {
         var passed = results.Count(r => r.Status == EnvironmentCheckStatus.Pass);
         var warnings = results.Count(r => r.Status == EnvironmentCheckStatus.Warning);
@@ -117,8 +83,7 @@ private void OutputJson(IReadOnlyList<EnvironmentCheckResult> results, IReadOnly
                 Passed = passed,
                 Warnings = warnings,
                 Failed = failed
-            },
-            Installations = installations.ToList()
+            }
         };
 
         var json = System.Text.Json.JsonSerializer.Serialize(response, JsonSourceGenerationContext.RelaxedEscaping.DoctorCheckResponse);
@@ -127,7 +92,7 @@ private void OutputJson(IReadOnlyList<EnvironmentCheckResult> results, IReadOnly
         InteractionService.DisplayRawText(json, ConsoleOutput.Standard);
     }
 
-    private void OutputHumanReadable(IReadOnlyList<EnvironmentCheckResult> results, IReadOnlyList<InstallationInfo> installations)
+    private void OutputHumanReadable(IReadOnlyList<EnvironmentCheckResult> results)
     {
         _ansiConsole.WriteLine();
         _ansiConsole.MarkupLine($"[bold]{DoctorCommandStrings.EnvironmentCheckHeader}[/]");
@@ -165,8 +130,6 @@ private void OutputHumanReadable(IReadOnlyList<EnvironmentCheckResult> results,
             const string prerequisitesUrl = "https://aka.ms/aspire-prerequisites";
             _ansiConsole.MarkupLine(string.Format(CultureInfo.CurrentCulture, DoctorCommandStrings.DetailedPrerequisitesLink, MarkupHelpers.SafeLink(InteractionService, prerequisitesUrl)));
         }
-
-        InstallationInfoOutput.OutputTable(_ansiConsole, installations);
     }
 
     private void OutputCheckResult(EnvironmentCheckResult result)
diff --git a/src/Aspire.Cli/Commands/InfoOptionAction.cs b/src/Aspire.Cli/Commands/InfoOptionAction.cs
new file mode 100644
index 00000000000..fa33f0f6ed0
--- /dev/null
+++ b/src/Aspire.Cli/Commands/InfoOptionAction.cs
@@ -0,0 +1,221 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.Text.Json;
+using Aspire.Cli.Acquisition;
+using Aspire.Cli.Interaction;
+using Microsoft.Extensions.Logging;
+
+namespace Aspire.Cli.Commands;
+
+/// <summary>
+/// Handles the root <c>--info</c> option:
+/// <list type="bullet">
+///   <item><c>aspire --info</c> — text: version + channel + install table.</item>
+///   <item><c>aspire --info --format json</c> — JSON object: <c>{ version, channel, installs[] }</c>.</item>
+///   <item><c>aspire --info --self</c> — text: just the running CLI's row.</item>
+///   <item><c>aspire --info --self --format json</c> — single-element <see cref="InstallationInfo"/>
+///     array. This shape is the cross-version peer-probe contract consumed by
+///     <see cref="PeerInstallProbe"/>; it intentionally omits the version/channel
+///     summary that the human form shows.</item>
+/// </list>
+/// </summary>
+/// <remarks>
+/// <para>
+/// Wired as the <see cref="Option.Action"/> on <see cref="RootCommand.InfoOption"/>
+/// so it short-circuits normal subcommand routing the same way <c>--help</c> and
+/// <c>--version</c> do.
+/// </para>
+/// <para>
+/// The action injects <see cref="IIdentityChannelReader"/> directly instead of
+/// reading <see cref="CliExecutionContext.IdentityChannel"/> so a CLI binary with
+/// missing/invalid <c>AspireCliChannel</c> assembly metadata can still render
+/// <c>--info</c> output. The factory in <c>Program.cs</c> wraps the eager
+/// <see cref="IIdentityChannelReader.ReadChannel"/> call in a <see cref="Lazy{T}"/>
+/// so <see cref="CliExecutionContext"/> resolves even when channel metadata is broken;
+/// this action then catches the <see cref="InvalidOperationException"/> from
+/// <see cref="IIdentityChannelReader.ReadChannel"/> and emits the row with the
+/// <c>channel</c> field omitted (JSON convention — null fields are dropped) or the
+/// <c>Channel</c> text row skipped, while still exiting 0.
+/// </para>
+/// </remarks>
+internal sealed class InfoOptionAction : AsynchronousCommandLineAction
+{
+    private readonly IInteractionService _interactionService;
+    private readonly IInstallationDiscovery _installationDiscovery;
+    private readonly HiveEnumerator _hiveEnumerator;
+    private readonly IIdentityChannelReader _identityChannelReader;
+    private readonly ILogger<InfoOptionAction> _logger;
+    private Option<bool>? _selfOption;
+    private Option<InfoOutputFormat>? _formatOption;
+
+    public InfoOptionAction(
+        IInteractionService interactionService,
+        IInstallationDiscovery installationDiscovery,
+        HiveEnumerator hiveEnumerator,
+        IIdentityChannelReader identityChannelReader,
+        ILogger<InfoOptionAction> logger)
+    {
+        ArgumentNullException.ThrowIfNull(interactionService);
+        ArgumentNullException.ThrowIfNull(installationDiscovery);
+        ArgumentNullException.ThrowIfNull(hiveEnumerator);
+        ArgumentNullException.ThrowIfNull(identityChannelReader);
+        ArgumentNullException.ThrowIfNull(logger);
+        _interactionService = interactionService;
+        _installationDiscovery = installationDiscovery;
+        _hiveEnumerator = hiveEnumerator;
+        _identityChannelReader = identityChannelReader;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Binds the <c>--self</c> and <c>--format</c> option instances that the
+    /// action will read from <see cref="ParseResult"/>. Called by
+    /// <see cref="RootCommand"/> at construction time after the options are
+    /// created. The options are per-RootCommand instance so that concurrent
+    /// tests building their own <see cref="RootCommand"/> instances don't
+    /// race on the action wiring.
+    /// </summary>
+    public void BindOptions(Option<bool> selfOption, Option<InfoOutputFormat> formatOption)
+    {
+        ArgumentNullException.ThrowIfNull(selfOption);
+        ArgumentNullException.ThrowIfNull(formatOption);
+        _selfOption = selfOption;
+        _formatOption = formatOption;
+    }
+
+    public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
+    {
+        if (_selfOption is null || _formatOption is null)
+        {
+            throw new InvalidOperationException($"{nameof(InfoOptionAction)} was invoked before {nameof(BindOptions)} was called.");
+        }
+
+        var format = parseResult.GetValue(_formatOption);
+        var self = parseResult.GetValue(_selfOption);
+
+        if (self)
+        {
+            return WriteSelf(format);
+        }
+
+        return await WriteFullInfoAsync(format, cancellationToken).ConfigureAwait(false);
+    }
+
+    private int WriteSelf(InfoOutputFormat format)
+    {
+        var rows = InstallationInfoOutput.DescribeSelfSafely(_installationDiscovery, _logger);
+        if (format == InfoOutputFormat.Json)
+        {
+            // Single-element array. Bit-for-bit identical to the previous
+            // `aspire --info --self --format json` contract so the
+            // PeerInstallProbe.TryParseRichProbeResult parser keeps working
+            // across CLI versions without a fallback.
+            var json = JsonSerializer.Serialize(rows.ToArray(), JsonSourceGenerationContext.RelaxedEscaping.InstallationInfoArray);
+            _interactionService.DisplayRawText(json, ConsoleOutput.Standard);
+            return CliExitCodes.Success;
+        }
+
+        foreach (var install in rows)
+        {
+            _interactionService.DisplayMarkdown("**self**");
+            DisplayField("Status", install.Status);
+            DisplayField("Channel", install.Channel);
+            DisplayField("Source", install.Source);
+            DisplayField("Version", install.Version);
+            DisplayField("Path", install.Path);
+            DisplayField("On PATH", install.PathStatus);
+        }
+
+        return CliExitCodes.Success;
+    }
+
+    private async Task<int> WriteFullInfoAsync(InfoOutputFormat format, CancellationToken cancellationToken)
+    {
+        var version = TryDescribeSelfVersion();
+        var channel = TryReadChannel();
+        var rows = await InstallationInfoOutput.BuildRowsSafelyAsync(_hiveEnumerator, _installationDiscovery, _logger, cancellationToken).ConfigureAwait(false);
+
+        if (format == InfoOutputFormat.Json)
+        {
+            var payload = new InfoOutput(version, channel, rows);
+            var json = JsonSerializer.Serialize(payload, JsonSourceGenerationContext.RelaxedEscaping.InfoOutput);
+            _interactionService.DisplayRawText(json, ConsoleOutput.Standard);
+            return CliExitCodes.Success;
+        }
+
+        DisplayField("Version", version);
+        DisplayField("Channel", channel);
+        _interactionService.DisplayEmptyLine();
+
+        foreach (var row in rows)
+        {
+            _interactionService.DisplayMarkdown($"**{row.Id}**  {row.Kind}");
+            DisplayField("Status", row.Status);
+            DisplayField("Channel", row.Channel);
+            DisplayField("Path", row.Path);
+            DisplayField("Hive", row.Hive);
+            if (row.StatusReason is { Length: > 0 })
+            {
+                DisplayField("Reason", row.StatusReason);
+            }
+            _interactionService.DisplayEmptyLine();
+        }
+
+        return CliExitCodes.Success;
+    }
+
+    private string? TryDescribeSelfVersion()
+    {
+        try
+        {
+            return _installationDiscovery.DescribeSelf().Version;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            // Match the tolerant posture of the channel-read path: a broken
+            // discovery shouldn't take the diagnostic command down with it.
+            _logger.LogWarning(ex, "Could not read the running Aspire CLI version for `aspire --info`.");
+            return null;
+        }
+    }
+
+    private string? TryReadChannel()
+    {
+        try
+        {
+            return _identityChannelReader.ReadChannel();
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            // Identity channel comes from AssemblyMetadata that the build system
+            // bakes; a missing/invalid value is a broken-binary signal but
+            // `aspire --info` is the surface a user reaches for to *find out*
+            // their binary is broken, so we must not crash here. The channel is
+            // dropped from JSON via DefaultIgnoreCondition.WhenWritingNull and
+            // omitted from the text rendering by `DisplayField`.
+            _logger.LogWarning(ex, "Could not read the running Aspire CLI identity channel for `aspire --info`.");
+            return null;
+        }
+    }
+
+    private void DisplayField(string name, string? value)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return;
+        }
+
+        _interactionService.DisplayPlainText($"  {name,-8} {value}");
+    }
+}
diff --git a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
index f7e1e1e30cb..51fa35d72a4 100644
--- a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
+++ b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
@@ -1,160 +1,250 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Text.Json.Serialization;
 using Aspire.Cli.Acquisition;
 using Aspire.Cli.Resources;
 using Microsoft.Extensions.Logging;
-using Spectre.Console;
 
 namespace Aspire.Cli.Commands;
 
+/// <summary>
+/// Shared helpers consumed by <see cref="InfoOptionAction"/>:
+/// <list type="bullet">
+///   <item><see cref="DescribeSelfSafely"/> — wraps <see cref="IInstallationDiscovery.DescribeSelf"/>
+///   with the failure-tolerant shape consumed by the peer-probe contract.</item>
+///   <item><see cref="BuildRowsAsync"/> and friends — classify a discovery walk into
+///   the <see cref="InstallListItem"/> rows surfaced by <c>aspire --info</c>.</item>
+/// </list>
+/// </summary>
+/// <remarks>
+/// Behavior of the row-builder and the JSON shape it produces is the
+/// cross-version peer-probe contract consumed by
+/// <see cref="Aspire.Cli.Acquisition.PeerInstallProbe"/> (and by external
+/// tooling reading <c>aspire --info --format json</c>); changes here must
+/// stay backwards-compatible with the parser in
+/// <c>PeerInstallProbe.TryParseRichProbeResult</c>.
+/// </remarks>
 internal static class InstallationInfoOutput
 {
-    public static async Task<IReadOnlyList<InstallationInfo>> DiscoverAllSafelyAsync(
-        IInstallationDiscovery discovery,
-        WingetFirstRunProbe wingetFirstRunProbe,
-        ILogger logger,
-        CancellationToken cancellationToken)
-    {
-        try
-        {
-            RunWingetFirstRunProbe(wingetFirstRunProbe);
-        }
-        catch (Exception ex) when (ex is not OperationCanceledException)
-        {
-            logger.LogWarning(ex, "Could not run the winget first-run install sidecar probe before doctor installation discovery.");
-        }
+    /// <summary>
+    /// Wire value for the <c>status</c> field of a hive-only row that has no
+    /// matching discovered install. Single source of truth for both the row
+    /// constructor in <see cref="BuildRowsAsync"/> and the sort-key switch in
+    /// <see cref="GetSortRank"/> so a future rename can't silently split the
+    /// two and demote orphan rows out of their last-sorted bucket.
+    /// </summary>
+    internal const string OrphanHiveStatus = "no install found";
 
+    public static IReadOnlyList<InstallationInfo> DescribeSelfSafely(IInstallationDiscovery discovery, ILogger logger)
+    {
         try
         {
-            logger.LogDebug("Discovering Aspire CLI installations for doctor output.");
-            var installations = await discovery.DiscoverAllAsync(cancellationToken).ConfigureAwait(false);
-            logger.LogDebug("Discovered {InstallationCount} Aspire CLI installation(s) for doctor output.", installations.Count);
-            return installations;
+            return [discovery.DescribeSelf()];
         }
         catch (OperationCanceledException)
         {
+            // Cancellation must propagate so the caller can honor the cancellation token
+            // even if DescribeSelf ever becomes cancellable.
             throw;
         }
         catch (Exception ex)
         {
-            logger.LogWarning(ex, "Could not discover Aspire CLI installations for doctor output.");
+            logger.LogWarning(ex, "Could not describe the running Aspire CLI installation for `aspire --info --self` output.");
             return CreateFailedDiscoveryRow();
         }
     }
 
-    public static IReadOnlyList<InstallationInfo> DescribeSelfSafely(IInstallationDiscovery discovery, ILogger logger)
+    public static async Task<List<InstallListItem>> BuildRowsSafelyAsync(HiveEnumerator hiveEnumerator, IInstallationDiscovery installationDiscovery, ILogger logger, CancellationToken cancellationToken)
     {
         try
         {
-            return [discovery.DescribeSelf()];
+            return await BuildRowsAsync(hiveEnumerator, installationDiscovery, logger, cancellationToken).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
-            // Symmetric with DiscoverAllSafelyAsync: cancellation must propagate
-            // so the caller can honor the cancellation token even if DescribeSelf
-            // ever becomes cancellable.
             throw;
         }
         catch (Exception ex)
         {
-            logger.LogWarning(ex, "Could not describe the running Aspire CLI installation for doctor self-probe output.");
-            return CreateFailedDiscoveryRow();
+            // Match the tolerant posture of the channel-read and self-version paths:
+            // a broken discovery walk (filesystem ACL, IO hiccup on
+            // ~/.aspire/hives, ...) shouldn't take the diagnostic command down
+            // with it. Surface a single failure row so the user sees that
+            // discovery ran but didn't produce data, plus the underlying reason.
+            logger.LogWarning(ex, "Install discovery walk failed for `aspire --info`.");
+            return
+            [
+                new InstallListItem(
+                    Id: "discovery",
+                    Kind: "discovery-failed",
+                    Channel: null,
+                    Path: null,
+                    Hive: null,
+                    Status: InstallationInfoStatus.Failed,
+                    StatusReason: ex.Message,
+                    ManagedBy: null)
+            ];
         }
     }
 
-    public static void RunWingetFirstRunProbe(WingetFirstRunProbe wingetFirstRunProbe)
+    public static async Task<List<InstallListItem>> BuildRowsAsync(HiveEnumerator hiveEnumerator, IInstallationDiscovery installationDiscovery, ILogger logger, CancellationToken cancellationToken)
     {
-        // Give a never-run winget install a chance to stamp its sidecar before
-        // we read it. The probe writes nothing on non-Windows hosts or when the
-        // running binary isn't a winget portable install, so this is a cheap
-        // no-op in the common case.
-        var processPath = Environment.ProcessPath;
-        if (string.IsNullOrEmpty(processPath))
-        {
-            return;
+        var discoveredInstalls = (await installationDiscovery.DiscoverAllAsync(cancellationToken))
+            .Where(i => IsDisplayableInstall(i, logger))
+            .ToList();
+        var installChannels = discoveredInstalls
+            .Select(i => i.Channel)
+            .Where(c => !string.IsNullOrEmpty(c))
+            .ToHashSet(StringComparer.Ordinal);
+        var ids = new Dictionary<string, int>(StringComparer.Ordinal);
+        var rows = new List<InstallListItem>();
+
+        foreach (var install in discoveredInstalls)
+        {
+            var baseId = GetInstallId(install);
+            var id = GetUniqueId(baseId, ids, logger);
+            var kind = GetInstallKind(install);
+            var status = GetInstallStatus(install);
+            var hive = install.Channel is { Length: > 0 } && hiveEnumerator.HasHive(install.Channel)
+                ? hiveEnumerator.GetHivePath(install.Channel)
+                : null;
+            var managedBy = GetManagedBy(install);
+            logger.LogDebug(
+                "Classified install path '{Path}' as id '{Id}', kind '{Kind}', channel '{Channel}', status '{Status}', hive '{Hive}', managedBy '{ManagedBy}'. Source='{Source}', pathStatus='{PathStatus}', discoveryStatus='{DiscoveryStatus}', reason='{Reason}'.",
+                install.Path,
+                id,
+                kind,
+                install.Channel ?? "(none)",
+                status,
+                hive ?? "(none)",
+                managedBy ?? "(none)",
+                install.Source ?? "(none)",
+                install.PathStatus,
+                install.Status,
+                install.StatusReason ?? "(none)");
+            rows.Add(new InstallListItem(id, kind, install.Channel, install.Path, hive, status, install.StatusReason, managedBy));
         }
 
-        var binaryDir = Path.GetDirectoryName(processPath);
-        if (!string.IsNullOrEmpty(binaryDir))
+        foreach (var hive in hiveEnumerator.GetHives().Where(h => !installChannels.Contains(h.Name)))
         {
-            wingetFirstRunProbe.Run(binaryDir);
+            var id = GetUniqueId(hive.Name, ids, logger);
+            logger.LogDebug(
+                "Classified hive '{Hive}' as orphan install row id '{Id}' because no discovered install reports channel '{Channel}'.",
+                hive.Path,
+                id,
+                hive.Name);
+            rows.Add(new InstallListItem(id, "orphan-hive", hive.Name, null, hive.Path, OrphanHiveStatus, "No discovered install reports this hive's channel.", null));
         }
+
+        return rows
+            .OrderBy(GetSortRank)
+            .ThenBy(row => row.Id, StringComparer.Ordinal)
+            .ToList();
     }
 
-    public static void OutputTable(IAnsiConsole ansiConsole, IReadOnlyList<InstallationInfo> installs)
+    private static int GetSortRank(InstallListItem row)
+        => row.Status switch
+        {
+            InstallationPathStatus.Active => 0,
+            InstallationPathStatus.Shadowed => 1,
+            InstallationPathStatus.NotOnPath => 2,
+            OrphanHiveStatus => 4,
+            _ => 3
+        };
+
+    private static string GetInstallId(InstallationInfo install)
     {
-        ansiConsole.WriteLine();
-        ansiConsole.MarkupLine($"[bold]{DoctorCommandStrings.HeaderInstallations.EscapeMarkup()}[/]");
-        ansiConsole.WriteLine(new string('=', DoctorCommandStrings.HeaderInstallations.Length));
-        ansiConsole.WriteLine();
-
-        var table = new Table()
-            .Border(TableBorder.Rounded)
-            .AddColumn(DoctorCommandStrings.ColumnPath)
-            .AddColumn(DoctorCommandStrings.ColumnVersion)
-            .AddColumn(DoctorCommandStrings.ColumnChannel)
-            .AddColumn(DoctorCommandStrings.ColumnRoute)
-            .AddColumn(DoctorCommandStrings.ColumnPathStatus);
-
-        // The first row is, by contract, the running CLI (enforced by
-        // InstallationDiscovery, not by ordering here). Tag installs[0]
-        // directly rather than re-resolving Environment.ProcessPath and
-        // matching CanonicalPath: that re-derivation can disagree with
-        // the discovery layer's notion of self (e.g. when ProcessPath is
-        // unresolvable at render time but was resolvable when DescribeSelf
-        // ran, or when a peer happens to share a canonical path with the
-        // running CLI).
-        for (var i = 0; i < installs.Count; i++)
-        {
-            var install = installs[i];
-            var isSelf = i == 0;
-            var pathDisplay = string.IsNullOrEmpty(install.Path)
-                ? DoctorCommandStrings.ValueUnknown
-                : install.Path;
-            pathDisplay = pathDisplay.EscapeMarkup();
-            if (isSelf)
-            {
-                pathDisplay = $"{pathDisplay} [grey]{DoctorCommandStrings.ValueCurrentMarker.EscapeMarkup()}[/]";
-            }
+        if (install.Source is "script")
+        {
+            return "script";
+        }
 
-            table.AddRow(
-                pathDisplay,
-                ValueOrPlaceholder(install.Version, install.Status),
-                ValueOrPlaceholder(install.Channel, install.Status),
-                ValueOrPlaceholder(install.Route, install.Status),
-                PathStatusDisplay(install.PathStatus));
+        if (!string.IsNullOrEmpty(install.Channel))
+        {
+            return install.Channel;
         }
 
-        ansiConsole.Write(table);
+        return install.Source ?? install.Path;
     }
 
-    private static string PathStatusDisplay(string pathStatus)
+    private static bool IsDisplayableInstall(InstallationInfo install, ILogger logger)
     {
-        return pathStatus switch
+        if (!string.IsNullOrEmpty(install.Source))
         {
-            InstallationPathStatus.Active => DoctorCommandStrings.ValuePathActive,
-            InstallationPathStatus.Shadowed => DoctorCommandStrings.ValuePathShadowed,
-            InstallationPathStatus.NotOnPath => DoctorCommandStrings.ValuePathNotOnPath,
-            _ => pathStatus.EscapeMarkup(),
-        };
+            logger.LogDebug("Including install path '{Path}' because it has source '{Source}'.", install.Path, install.Source);
+            return true;
+        }
+
+        var fileName = Path.GetFileName(install.CanonicalPath ?? install.Path);
+        var isAspireBinary = fileName is "aspire" or "aspire.exe";
+        if (!isAspireBinary)
+        {
+            logger.LogDebug("Ignoring discovery row path '{Path}' because it has no install source and the resolved filename '{FileName}' is not an Aspire CLI binary.", install.Path, fileName);
+        }
+
+        return isAspireBinary;
     }
 
-    private static string ValueOrPlaceholder(string? value, string status)
+    private static string GetUniqueId(string id, Dictionary<string, int> ids, ILogger logger)
     {
-        if (!string.IsNullOrEmpty(value))
+        var originalId = id;
+        var uniqueId = GetUniqueIdCore(id, ids);
+        if (!string.Equals(originalId, uniqueId, StringComparison.Ordinal))
         {
-            return value.EscapeMarkup();
+            logger.LogDebug("Disambiguated duplicate install id '{OriginalId}' as '{UniqueId}'.", originalId, uniqueId);
         }
 
-        // Missing fields mean different things for skipped rows, failed
-        // probes, and rows that responded but did not populate this value.
-        return status switch
+        return uniqueId;
+    }
+
+    private static string GetUniqueIdCore(string id, Dictionary<string, int> ids)
+    {
+        if (!ids.TryGetValue(id, out var count))
         {
-            InstallationInfoStatus.NotProbed => DoctorCommandStrings.ValueNotProbed,
-            InstallationInfoStatus.Failed => DoctorCommandStrings.ValueProbeFailed,
-            _ => DoctorCommandStrings.ValueUnknown,
+            ids[id] = 1;
+            return id;
+        }
+
+        count++;
+        ids[id] = count;
+        return $"{id}-{count}";
+    }
+
+    private static string GetInstallKind(InstallationInfo install)
+        => install.Source switch
+        {
+            // The sidecar wire string is "brew" but everywhere we surface this to
+            // a human (or tool reading our JSON output) we use the friendlier
+            // "homebrew" label so the displayed `kind` and `managedBy` agree.
+            "brew" => "homebrew",
+            null => "unknown",
+            _ => install.Source,
         };
+
+    private static string? GetManagedBy(InstallationInfo install)
+        => install.Source switch
+        {
+            "dotnet-tool" => "dotnet-tool",
+            "winget" => "winget",
+            "brew" => "homebrew",
+            _ => null
+        };
+
+    private static string GetInstallStatus(InstallationInfo install)
+    {
+        // Keep `status` enum-shaped so programmatic consumers can switch on it.
+        // For non-Ok rows the discovery status ("failed" / "notProbed") is
+        // surfaced here; the human-readable reason rides on the separate
+        // `statusReason` field (see `docs/specs/cli-output-formats.md`). For Ok
+        // rows the path-status axis is what users actually want to act on, so
+        // we project that into `status` instead of always emitting "ok".
+        if (install.Status != InstallationInfoStatus.Ok)
+        {
+            return install.Status;
+        }
+
+        return install.PathStatus;
     }
 
     private static IReadOnlyList<InstallationInfo> CreateFailedDiscoveryRow()
@@ -172,3 +262,36 @@ private static IReadOnlyList<InstallationInfo> CreateFailedDiscoveryRow()
         ];
     }
 }
+
+/// <summary>
+/// One row in the <c>aspire --info</c> install table. Surfaced as JSON when
+/// <c>--format json</c> is set.
+/// </summary>
+internal sealed record InstallListItem(
+    [property: JsonPropertyName("id")] string Id,
+    [property: JsonPropertyName("kind")] string Kind,
+    [property: JsonPropertyName("channel")] string? Channel,
+    [property: JsonPropertyName("path")] string? Path,
+    [property: JsonPropertyName("hive")] string? Hive,
+    [property: JsonPropertyName("status")] string Status,
+    [property: JsonPropertyName("statusReason")] string? StatusReason,
+    [property: JsonPropertyName("managedBy")] string? ManagedBy);
+
+/// <summary>
+/// Combined object emitted by <c>aspire --info --format json</c>. The
+/// per-install rows are produced by <see cref="InstallationInfoOutput.BuildRowsAsync"/>.
+/// </summary>
+internal sealed record InfoOutput(
+    [property: JsonPropertyName("version")] string? Version,
+    [property: JsonPropertyName("channel")] string? Channel,
+    [property: JsonPropertyName("installs")] IReadOnlyList<InstallListItem> Installs);
+
+/// <summary>
+/// Output format for <c>aspire --info</c>. <c>List</c> is the default text
+/// rendering; <c>Json</c> is the machine-readable shape.
+/// </summary>
+internal enum InfoOutputFormat
+{
+    List,
+    Json,
+}
diff --git a/src/Aspire.Cli/Commands/RootCommand.cs b/src/Aspire.Cli/Commands/RootCommand.cs
index 4272341fddf..e9415f3dd78 100644
--- a/src/Aspire.Cli/Commands/RootCommand.cs
+++ b/src/Aspire.Cli/Commands/RootCommand.cs
@@ -3,11 +3,12 @@
 
 using System.CommandLine;
 using System.CommandLine.Help;
+using System.CommandLine.Parsing;
+using System.Globalization;
 using Microsoft.Extensions.Logging;
 using Spectre.Console;
 
 #if DEBUG
-using System.Globalization;
 using System.Diagnostics;
 #endif
 
@@ -49,6 +50,64 @@ internal sealed class RootCommand : BaseRootCommand
         Recursive = true
     };
 
+    /// <summary>
+    /// Root-level <c>--info</c> flag that prints the running CLI's version,
+    /// channel, and the list of Aspire CLI installs discovered on this machine.
+    /// Root-only (non-recursive): <c>aspire --info</c> fires the install-info
+    /// surface, while <c>aspire &lt;subcommand&gt; --info</c> is a separate
+    /// operation — the unmatched <c>--info</c> token does not bind at
+    /// subcommand scope, the action does not fire, and the subcommand runs
+    /// normally. Keeping install enumeration root-only avoids the recursive-option
+    /// / subcommand-local <c>--format</c> shadowing trap, where a recursive
+    /// root <c>--format</c> would be quietly swallowed by a subcommand's own
+    /// <c>--format</c> option. Wired to <see cref="InfoOptionAction"/> in the
+    /// constructor so it short-circuits subcommand routing when set on root
+    /// (the same way <c>--help</c> and <c>--version</c> do). Per-instance (not
+    /// static): the option carries the <see cref="InfoOptionAction"/> bound to
+    /// *this* <see cref="RootCommand"/>'s service provider, so concurrent tests
+    /// that each build their own <see cref="RootCommand"/> don't fight over
+    /// the <see cref="Option.Action"/> mutation.
+    /// </summary>
+    public readonly Option<bool> InfoOption = new(CommonOptionNames.Info)
+    {
+        Description = RootCommandStrings.InfoArgumentDescription,
+    };
+
+    /// <summary>
+    /// Hidden modifier for <see cref="InfoOption"/>. When set, the action
+    /// emits only the running CLI's row instead of the full install table.
+    /// Reused as the cross-version peer-probe contract: in JSON mode the
+    /// output is a single-element <see cref="Acquisition.InstallationInfo"/> array
+    /// (see <see cref="Acquisition.PeerInstallProbe"/>). Root-only to match
+    /// <see cref="InfoOption"/>. Per-instance for the same reason as
+    /// <see cref="InfoOption"/>: the "requires <c>--info</c>" validator added
+    /// in the constructor would otherwise accumulate across concurrent
+    /// <see cref="RootCommand"/> constructions.
+    /// </summary>
+    public readonly Option<bool> InfoSelfOption = new("--self")
+    {
+        Hidden = true
+    };
+
+    /// <summary>
+    /// Hidden output-format modifier for <see cref="InfoOption"/>. Accepts
+    /// <c>list</c> (the default text rendering) or <c>json</c>. Hidden because
+    /// it is only meaningful when paired with <c>--info</c>. Root-only to
+    /// match <see cref="InfoOption"/>: keeping <c>--format</c> non-recursive
+    /// here avoids shadowing subcommand-local <c>--format</c> options (e.g.
+    /// <c>aspire doctor --format json</c>, <c>aspire run --format json</c>),
+    /// which both define their own <c>--format</c> with a different value set.
+    /// Per-instance for the same reason as <see cref="InfoOption"/>: the
+    /// "requires <c>--info</c>" validator added in the constructor would
+    /// otherwise accumulate across concurrent <see cref="RootCommand"/>
+    /// constructions.
+    /// </summary>
+    public readonly Option<InfoOutputFormat> InfoFormatOption = new("--format")
+    {
+        Description = RootCommandStrings.InfoFormatArgumentDescription,
+        Hidden = true
+    };
+
     public static readonly Option<bool> BannerOption = new(CommonOptionNames.Banner)
     {
         Description = RootCommandStrings.BannerArgumentDescription,
@@ -174,7 +233,8 @@ public RootCommand(
         ExtensionInternalCommand extensionInternalCommand,
         IBundleService bundleService,
         IInteractionService interactionService,
-        IAnsiConsole ansiConsole)
+        IAnsiConsole ansiConsole,
+        InfoOptionAction infoOptionAction)
         : base(RootCommandStrings.Description)
     {
         _interactionService = interactionService;
@@ -210,6 +270,9 @@ public RootCommand(
         Options.Add(BannerOption);
         Options.Add(WaitForDebuggerOption);
         Options.Add(CliWaitForDebuggerOption);
+        Options.Add(InfoOption);
+        Options.Add(InfoSelfOption);
+        Options.Add(InfoFormatOption);
         if (ExtensionHelper.IsExtensionHost(interactionService, out _, out _))
         {
             Options.Add(StartDebugSessionOption);
@@ -218,6 +281,18 @@ public RootCommand(
         Options.Add(CaptureProfileOutputOption);
         Options.Add(CaptureProfileDelayOption);
 
+        // Wire the --info action so it short-circuits subcommand routing the
+        // same way --help / --version do. Also gate --self and --format on
+        // --info via validators so `aspire --self` and `aspire --format json`
+        // (the only shapes that can reach these root-only options without
+        // also setting --info) fail parse loudly instead of falling through
+        // to grouped help.
+        infoOptionAction.BindOptions(InfoSelfOption, InfoFormatOption);
+        InfoOption.Action = infoOptionAction;
+        var infoOption = InfoOption;
+        InfoSelfOption.Validators.Add(result => ValidateRequiresInfo(result, InfoSelfOption, infoOption));
+        InfoFormatOption.Validators.Add(result => ValidateRequiresInfo(result, InfoFormatOption, infoOption));
+
         // Handle standalone 'aspire' or 'aspire --banner' (no subcommand)
         this.SetAction((Func<ParseResult, CancellationToken, Task<int>>)((context, cancellationToken) =>
         {
@@ -293,4 +368,27 @@ public RootCommand(
         }
 
     }
+
+    /// <summary>
+    /// Fails parse when <paramref name="option"/> is supplied without
+    /// <paramref name="infoOption"/>. <see cref="InfoSelfOption"/> and
+    /// <see cref="InfoFormatOption"/> are only meaningful as modifiers on
+    /// <c>--info</c>; without this validator <c>aspire --self</c> or
+    /// <c>aspire --format json</c> would parse cleanly and either fall
+    /// through to grouped help or — worse, for <c>--format</c> — swallow
+    /// values intended for a subcommand option.
+    /// </summary>
+    private static void ValidateRequiresInfo(OptionResult result, Option option, Option<bool> infoOption)
+    {
+        if (result.Implicit)
+        {
+            return;
+        }
+
+        var info = result.Parent?.GetResult(infoOption);
+        if (info is null || info.Implicit)
+        {
+            result.AddError(string.Format(CultureInfo.CurrentCulture, RootCommandStrings.InfoOptionRequiresInfo, option.Name));
+        }
+    }
 }
diff --git a/src/Aspire.Cli/CommonOptionNames.cs b/src/Aspire.Cli/CommonOptionNames.cs
index 846b5ff2598..8d80e1586df 100644
--- a/src/Aspire.Cli/CommonOptionNames.cs
+++ b/src/Aspire.Cli/CommonOptionNames.cs
@@ -13,6 +13,7 @@ internal static class CommonOptionNames
     public const string Help = "--help";
     public const string HelpShort = "-h";
     public const string HelpAlt = "-?";
+    public const string Info = "--info";
     public const string NoLogo = "--nologo";
     public const string Banner = "--banner";
     public const string Debug = "--debug";
@@ -23,8 +24,11 @@ internal static class CommonOptionNames
     public const string StartDebugSession = "--start-debug-session";
 
     /// <summary>
-    /// Options that represent informational commands (e.g. --version, --help) which should
-    /// opt out of telemetry and suppress first-run experience.
+    /// Options that represent informational commands (e.g. --version, --help, --info) which
+    /// should opt out of telemetry and suppress the first-run experience. `--info` is included
+    /// because its text form does not consume a `--format json` token (handled separately by
+    /// <c>HasMachineReadableOutputFormat</c>) but must not consume the one-shot first-run sentinel
+    /// or start a tracked telemetry activity.
     /// </summary>
-    public static readonly string[] InformationalOptionNames = [Version, Help, HelpShort, HelpAlt];
+    public static readonly string[] InformationalOptionNames = [Version, Help, HelpShort, HelpAlt, Info];
 }
diff --git a/src/Aspire.Cli/JsonSourceGenerationContext.cs b/src/Aspire.Cli/JsonSourceGenerationContext.cs
index 1418074f283..4e34f05cc2b 100644
--- a/src/Aspire.Cli/JsonSourceGenerationContext.cs
+++ b/src/Aspire.Cli/JsonSourceGenerationContext.cs
@@ -54,6 +54,9 @@ namespace Aspire.Cli;
 [JsonSerializable(typeof(CandidateAppHostDisplayInfo))]
 [JsonSerializable(typeof(List<CandidateAppHostDisplayInfo>))]
 [JsonSerializable(typeof(InstallationInfo))]
+[JsonSerializable(typeof(InstallationInfo[]))]
+[JsonSerializable(typeof(List<InstallListItem>))]
+[JsonSerializable(typeof(InfoOutput))]
 [JsonSerializable(typeof(AppHostInfoCacheEntry))]
 [JsonSerializable(typeof(AppHostProjectInspectionOutput))]
 internal partial class JsonSourceGenerationContext : JsonSerializerContext
diff --git a/src/Aspire.Cli/Program.cs b/src/Aspire.Cli/Program.cs
index dc8df361491..e7b218488bc 100644
--- a/src/Aspire.Cli/Program.cs
+++ b/src/Aspire.Cli/Program.cs
@@ -350,8 +350,31 @@ internal static async Task<IHost> BuildApplicationAsync(string[] args, CliStartu
         builder.Services.AddSingleton(sp =>
         {
             var channelReader = sp.GetRequiredService<IIdentityChannelReader>();
-            var channel = channelReader.ReadChannel();
-            return BuildCliExecutionContext(startupContext.LoggingOptions.DebugMode, startupContext.LoggingOptions.LogsDirectory, startupContext.LoggingOptions.LogFilePath, channel);
+            // Defer channelReader.ReadChannel() so a CLI binary with missing
+            // or invalid AspireCliChannel assembly metadata can still resolve
+            // CliExecutionContext. Without the Lazy<>, this factory would
+            // throw before any subcommand or root-option action runs, and the
+            // diagnostic path (`aspire --info`, `aspire --help`) would crash
+            // along with everything else. Consumers that genuinely need the
+            // channel (PackagingService, UpdateCommand, NewCommand,
+            // InitCommand, ...) still see the original throwing semantics on
+            // first access of CliExecutionContext.IdentityChannel — only the
+            // resolution point moves. InfoOptionAction bypasses this entirely
+            // by injecting IIdentityChannelReader and handling failure itself.
+            var lazyChannel = new Lazy<string>(channelReader.ReadChannel, LazyThreadSafetyMode.ExecutionAndPublication);
+            // Self-heal the install-source sidecar before anything reads it.
+            // WingetFirstRunProbe is a one-shot writer (no-op on non-Windows or
+            // when the running binary isn't a winget portable install). Running
+            // it here, inside the CliExecutionContext factory, guarantees the
+            // sidecar is stamped before BuildCliExecutionContext below resolves
+            // the install-aware Aspire home, before BundleService computes its
+            // extract dir, and before `aspire --info --self` reads `Source`.
+            // Without this, the first invocation from a fresh winget install
+            // would fall back to the legacy user-profile home and miss the
+            // source row, even though the sidecar would appear on subsequent
+            // runs. The probe is idempotent, so the worst case here is a no-op.
+            TryRunWingetFirstRunProbe(sp);
+            return BuildCliExecutionContext(startupContext.LoggingOptions.DebugMode, startupContext.LoggingOptions.LogsDirectory, startupContext.LoggingOptions.LogFilePath, lazyChannel);
         });
         builder.Services.AddSingleton(s => new ConsoleEnvironment(
             BuildAnsiConsole(s, Console.Out),
@@ -580,6 +603,8 @@ internal static async Task<IHost> BuildApplicationAsync(string[] args, CliStartu
 #endif
         builder.Services.AddTransient<RootCommand>();
         builder.Services.AddTransient<ExtensionInternalCommand>();
+        builder.Services.AddTransient<Acquisition.HiveEnumerator>();
+        builder.Services.AddTransient<InfoOptionAction>();
 
         var app = builder.Build();
         return app;
@@ -600,6 +625,12 @@ private static DirectoryInfo GetSdksDirectory(string? processPath = null)
     }
 
     internal static CliExecutionContext BuildCliExecutionContext(bool debugMode, string logsDirectory, string logFilePath, string channel, string? processPath = null)
+        => BuildCliExecutionContextCore(debugMode, logsDirectory, logFilePath, channel, identityChannelLazy: null, processPath);
+
+    internal static CliExecutionContext BuildCliExecutionContext(bool debugMode, string logsDirectory, string logFilePath, Lazy<string> identityChannelLazy, string? processPath = null)
+        => BuildCliExecutionContextCore(debugMode, logsDirectory, logFilePath, channel: "local", identityChannelLazy, processPath);
+
+    private static CliExecutionContext BuildCliExecutionContextCore(bool debugMode, string logsDirectory, string logFilePath, string channel, Lazy<string>? identityChannelLazy, string? processPath)
     {
         var workingDirectory = new DirectoryInfo(Environment.CurrentDirectory);
         var hivesDirectory = GetHivesDirectory(processPath);
@@ -607,7 +638,45 @@ internal static CliExecutionContext BuildCliExecutionContext(bool debugMode, str
         var sdksDirectory = GetSdksDirectory(processPath);
         var packagesDirectory = GetPackagesDirectory(processPath);
         var aspireHomeDirectory = new DirectoryInfo(GetUsersAspirePath(processPath));
-        return new CliExecutionContext(workingDirectory, hivesDirectory, cacheDirectory, sdksDirectory, new DirectoryInfo(logsDirectory), logFilePath, debugMode, packagesDirectory: packagesDirectory, identityChannel: channel, aspireHomeDirectory: aspireHomeDirectory);
+        return new CliExecutionContext(workingDirectory, hivesDirectory, cacheDirectory, sdksDirectory, new DirectoryInfo(logsDirectory), logFilePath, debugMode, packagesDirectory: packagesDirectory, identityChannel: channel, aspireHomeDirectory: aspireHomeDirectory)
+        {
+            IdentityChannelLazy = identityChannelLazy,
+        };
+    }
+
+    /// <summary>
+    /// Invokes <see cref="WingetFirstRunProbe.Run(string)"/> for the running binary's
+    /// directory, swallowing any failure so a misbehaving probe can never block CLI startup.
+    /// Called from the <see cref="CliExecutionContext"/> DI factory so the sidecar is
+    /// stamped before any code reads it.
+    /// </summary>
+    internal static void TryRunWingetFirstRunProbe(IServiceProvider sp)
+    {
+        try
+        {
+            var processPath = Environment.ProcessPath;
+            if (string.IsNullOrEmpty(processPath))
+            {
+                return;
+            }
+
+            var binaryDir = Path.GetDirectoryName(processPath);
+            if (string.IsNullOrEmpty(binaryDir))
+            {
+                return;
+            }
+
+            sp.GetRequiredService<WingetFirstRunProbe>().Run(binaryDir);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            // The probe is best-effort startup hygiene: a stamping failure must
+            // never block the rest of the CLI from starting. Log and continue —
+            // the worst case is that an unstamped winget install surfaces as an
+            // unknown source until the next invocation retries.
+            var logger = sp.GetService<ILogger<WingetFirstRunProbe>>();
+            logger?.LogWarning(ex, "Winget first-run install sidecar probe failed during CLI startup.");
+        }
     }
 
     private static DirectoryInfo GetCacheDirectory(string? processPath = null)
@@ -700,9 +769,9 @@ internal static async Task DisplayFirstTimeUseNoticeIfNeededAsync(IServiceProvid
                 consoleEnvironment.Error.WriteLine();
             }
 
-            // Don't persist the sentinel for informational commands (--version, --help, etc.)
+            // Don't persist the sentinel for informational commands (--version, --help, --info, etc.)
             // or for machine-readable invocations (--format json, including the hidden
-            // `doctor --self --format json` peer probe). Otherwise an automation invocation
+            // `--info --self --format json` peer probe). Otherwise an automation invocation
             // or peer probe — which deliberately suppressed the user-facing notice — would
             // silently consume the first-run slot, and the next interactive invocation by
             // the same user would never see the telemetry notice.
@@ -715,8 +784,8 @@ internal static async Task DisplayFirstTimeUseNoticeIfNeededAsync(IServiceProvid
 
     // Machine-readable output flags should never have welcome/telemetry text
     // interleaved with the structured payload. Today the only such flag is
-    // `--format json` (consumed by `aspire doctor`); extend this scan if new
-    // options are added.
+    // `--format json` (consumed by `aspire doctor` and `aspire --info`); extend
+    // this scan if new options are added.
     private static bool HasMachineReadableOutputFormat(string[] args)
     {
         for (var i = 0; i < args.Length; i++)
diff --git a/src/Aspire.Cli/Resources/DoctorCommandStrings.Designer.cs b/src/Aspire.Cli/Resources/DoctorCommandStrings.Designer.cs
index 6da919dceb0..20559bfa13e 100644
--- a/src/Aspire.Cli/Resources/DoctorCommandStrings.Designer.cs
+++ b/src/Aspire.Cli/Resources/DoctorCommandStrings.Designer.cs
@@ -401,123 +401,6 @@ public static string DevCertsTrustLabelPartial {
             }
         }
 
-        /// <summary>
-        ///   Looks up a localized string similar to Aspire CLI Installations.
-        /// </summary>
-        public static string HeaderInstallations {
-            get {
-                return ResourceManager.GetString("HeaderInstallations", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Path.
-        /// </summary>
-        public static string ColumnPath {
-            get {
-                return ResourceManager.GetString("ColumnPath", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Version.
-        /// </summary>
-        public static string ColumnVersion {
-            get {
-                return ResourceManager.GetString("ColumnVersion", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Channel.
-        /// </summary>
-        public static string ColumnChannel {
-            get {
-                return ResourceManager.GetString("ColumnChannel", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Route.
-        /// </summary>
-        public static string ColumnRoute {
-            get {
-                return ResourceManager.GetString("ColumnRoute", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to PATH status.
-        /// </summary>
-        public static string ColumnPathStatus {
-            get {
-                return ResourceManager.GetString("ColumnPathStatus", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to (current).
-        /// </summary>
-        public static string ValueCurrentMarker {
-            get {
-                return ResourceManager.GetString("ValueCurrentMarker", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to (unknown).
-        /// </summary>
-        public static string ValueUnknown {
-            get {
-                return ResourceManager.GetString("ValueUnknown", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to (not probed).
-        /// </summary>
-        public static string ValueNotProbed {
-            get {
-                return ResourceManager.GetString("ValueNotProbed", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to (probe failed).
-        /// </summary>
-        public static string ValueProbeFailed {
-            get {
-                return ResourceManager.GetString("ValueProbeFailed", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to active.
-        /// </summary>
-        public static string ValuePathActive {
-            get {
-                return ResourceManager.GetString("ValuePathActive", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to shadowed.
-        /// </summary>
-        public static string ValuePathShadowed {
-            get {
-                return ResourceManager.GetString("ValuePathShadowed", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to not on PATH.
-        /// </summary>
-        public static string ValuePathNotOnPath {
-            get {
-                return ResourceManager.GetString("ValuePathNotOnPath", resourceCulture);
-            }
-        }
-
         /// <summary>
         ///   Looks up a localized string similar to Install discovery failed. See the Aspire CLI logs for details..
         /// </summary>
diff --git a/src/Aspire.Cli/Resources/DoctorCommandStrings.resx b/src/Aspire.Cli/Resources/DoctorCommandStrings.resx
index 815d879d300..9f7ff7a9d1e 100644
--- a/src/Aspire.Cli/Resources/DoctorCommandStrings.resx
+++ b/src/Aspire.Cli/Resources/DoctorCommandStrings.resx
@@ -181,52 +181,6 @@
   <data name="DevCertsTrustLabelPartial" xml:space="preserve">
     <value>[partial]</value>
   </data>
-  <data name="HeaderInstallations" xml:space="preserve">
-    <value>Aspire CLI Installations</value>
-  </data>
-  <data name="ColumnPath" xml:space="preserve">
-    <value>Path</value>
-  </data>
-  <data name="ColumnVersion" xml:space="preserve">
-    <value>Version</value>
-  </data>
-  <data name="ColumnChannel" xml:space="preserve">
-    <value>Channel</value>
-  </data>
-  <data name="ColumnRoute" xml:space="preserve">
-    <value>Route</value>
-  </data>
-  <data name="ColumnPathStatus" xml:space="preserve">
-    <value>PATH status</value>
-  </data>
-  <data name="ValueCurrentMarker" xml:space="preserve">
-    <value>(current)</value>
-    <comment>Suffix appended to the running CLI's path so the user can identify which install is themselves.</comment>
-  </data>
-  <data name="ValueUnknown" xml:space="preserve">
-    <value>(unknown)</value>
-    <comment>Placeholder shown in the table when a field could not be determined for a discovered install.</comment>
-  </data>
-  <data name="ValueNotProbed" xml:space="preserve">
-    <value>(not probed)</value>
-    <comment>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</comment>
-  </data>
-  <data name="ValueProbeFailed" xml:space="preserve">
-    <value>(probe failed)</value>
-    <comment>Placeholder shown in the table when an install was probed but did not return usable data.</comment>
-  </data>
-  <data name="ValuePathActive" xml:space="preserve">
-    <value>active</value>
-    <comment>Shown when an install is the first Aspire CLI resolved from PATH.</comment>
-  </data>
-  <data name="ValuePathShadowed" xml:space="preserve">
-    <value>shadowed</value>
-    <comment>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</comment>
-  </data>
-  <data name="ValuePathNotOnPath" xml:space="preserve">
-    <value>not on PATH</value>
-    <comment>Shown when an install was not discovered from PATH.</comment>
-  </data>
   <data name="InstallationDiscoveryFailedReason" xml:space="preserve">
     <value>Install discovery failed. See the Aspire CLI logs for details.</value>
   </data>
diff --git a/src/Aspire.Cli/Resources/RootCommandStrings.Designer.cs b/src/Aspire.Cli/Resources/RootCommandStrings.Designer.cs
index dcccd1190f0..65dc2ec7d62 100644
--- a/src/Aspire.Cli/Resources/RootCommandStrings.Designer.cs
+++ b/src/Aspire.Cli/Resources/RootCommandStrings.Designer.cs
@@ -155,6 +155,33 @@ public static string NonInteractiveArgumentDescription {
             }
         }
 
+        /// <summary>
+        ///   Looks up a localized string similar to Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine.
+        /// </summary>
+        public static string InfoArgumentDescription {
+            get {
+                return ResourceManager.GetString("InfoArgumentDescription", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Output format for `--info`.
+        /// </summary>
+        public static string InfoFormatArgumentDescription {
+            get {
+                return ResourceManager.GetString("InfoFormatArgumentDescription", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Option `{0}` is only valid when `--info` is also specified..
+        /// </summary>
+        public static string InfoOptionRequiresInfo {
+            get {
+                return ResourceManager.GetString("InfoOptionRequiresInfo", resourceCulture);
+            }
+        }
+
         /// <summary>
         ///   Looks up a localized string similar to Wait for a debugger to attach before executing the command..
         /// </summary>
diff --git a/src/Aspire.Cli/Resources/RootCommandStrings.resx b/src/Aspire.Cli/Resources/RootCommandStrings.resx
index 23d1429b35d..c9cae39da55 100644
--- a/src/Aspire.Cli/Resources/RootCommandStrings.resx
+++ b/src/Aspire.Cli/Resources/RootCommandStrings.resx
@@ -150,6 +150,15 @@
   <data name="NonInteractiveArgumentDescription" xml:space="preserve">
     <value>Run the command in non-interactive mode, disabling all interactive prompts and spinners</value>
   </data>
+  <data name="InfoArgumentDescription" xml:space="preserve">
+    <value>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</value>
+  </data>
+  <data name="InfoFormatArgumentDescription" xml:space="preserve">
+    <value>Output format for `--info`</value>
+  </data>
+  <data name="InfoOptionRequiresInfo" xml:space="preserve">
+    <value>Option `{0}` is only valid when `--info` is also specified.</value>
+  </data>
   <data name="FirstTimeUseTelemetryNotice" xml:space="preserve">
     <value>Telemetry
 ---------
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.cs.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.cs.xlf
index 7ace9ee9b0e..5d3573e97b9 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.cs.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.cs.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Modul runtime kontejneru</target>
@@ -197,11 +172,6 @@
         <target state="translated">Kontrola prostředí Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Shrnutí – úspěšné: {0}, upozornění: {1}, selhalo: {2}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.de.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.de.xlf
index b1ee92460c2..1cd2aade788 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.de.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.de.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Containerruntime</target>
@@ -197,11 +172,6 @@
         <target state="translated">Überprüfung der Aspire-Umgebung</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Zusammenfassung: {0} erfolgreich, {1} Warnungen, {2} fehlgeschlagen</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.es.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.es.xlf
index c460c528f4d..ff2edca38c1 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.es.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.es.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Tiempo de ejecución del contenedor</target>
@@ -197,11 +172,6 @@
         <target state="translated">Comprobación del entorno de Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Resumen: {0} correctos, {1} advertencias, {2} fallos</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.fr.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.fr.xlf
index da57cb33781..8e7392f34a2 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.fr.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.fr.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Runtime de conteneur</target>
@@ -197,11 +172,6 @@
         <target state="translated">Vérification de l’environnement Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Résumé : {0} réussis, {1} avertissements, {2} échoués</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.it.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.it.xlf
index 84288f06ea6..d47b8903e5e 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.it.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.it.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Runtime del contenitore</target>
@@ -197,11 +172,6 @@
         <target state="translated">Verifica ambiente Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Riepilogo: {0} superati, {1} avvisi, {2} non superati</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ja.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ja.xlf
index 86467014737..7effce74f2c 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ja.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ja.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">コンテナー ランタイム</target>
@@ -197,11 +172,6 @@
         <target state="translated">Aspire 環境確認</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">概要: {0} 成功、{1} 警告、{2} 失敗</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ko.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ko.xlf
index 374618a94c3..7b63ef03995 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ko.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ko.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">컨테이너 런타임</target>
@@ -197,11 +172,6 @@
         <target state="translated">Aspire 환경 검사</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">요약: {0}개 통과, {1}개 경고, {2}개 실패</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pl.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pl.xlf
index c6059837b7a..beef71a3f5e 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pl.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pl.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Środowisko uruchomieniowe kontenera</target>
@@ -197,11 +172,6 @@
         <target state="translated">Sprawdzanie środowiska Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Podsumowanie: zaliczone {0}, ostrzeżenia {1}, niezaliczone {2}</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pt-BR.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pt-BR.xlf
index 0fbc55e2649..57cc37fb6e2 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pt-BR.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.pt-BR.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Runtime do Contêiner</target>
@@ -197,11 +172,6 @@
         <target state="translated">Verificação de Ambiente do Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Resumo: {0} aprovado, {1} avisos, {2} falha</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ru.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ru.xlf
index c7c56da3860..97a056dea2a 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ru.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.ru.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Среда выполнения контейнера</target>
@@ -197,11 +172,6 @@
         <target state="translated">Проверка среды Aspire</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Сводка: {0} успешно, предупреждений: {1}, {2} с ошибками</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.tr.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.tr.xlf
index 684b71ccfb7..c26f0f88b04 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.tr.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.tr.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">Kapsayıcı Çalışma Zamanı</target>
@@ -197,11 +172,6 @@
         <target state="translated">Aspire Ortamı Kontrolü</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">Özet: {0} başarılı, {1} uyarı, {2} başarısız</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hans.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hans.xlf
index fc2a1cf2c0b..55406a45d0f 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hans.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hans.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">容器运行时</target>
@@ -197,11 +172,6 @@
         <target state="translated">Aspire 环境检查</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">摘要: {0} 通过,{1} 警告， {2} 失败</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hant.xlf b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hant.xlf
index 7b50606a224..17ae0025436 100644
--- a/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hant.xlf
+++ b/src/Aspire.Cli/Resources/xlf/DoctorCommandStrings.zh-Hant.xlf
@@ -57,31 +57,6 @@
         <target state="new">Could not check for Aspire CLI updates</target>
         <note />
       </trans-unit>
-      <trans-unit id="ColumnChannel">
-        <source>Channel</source>
-        <target state="new">Channel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPath">
-        <source>Path</source>
-        <target state="new">Path</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnPathStatus">
-        <source>PATH status</source>
-        <target state="new">PATH status</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnRoute">
-        <source>Route</source>
-        <target state="new">Route</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ColumnVersion">
-        <source>Version</source>
-        <target state="new">Version</target>
-        <note />
-      </trans-unit>
       <trans-unit id="ContainerCategoryHeader">
         <source>Container Runtime</source>
         <target state="translated">容器執行階段</target>
@@ -197,11 +172,6 @@
         <target state="translated">Aspire 環境檢查</target>
         <note />
       </trans-unit>
-      <trans-unit id="HeaderInstallations">
-        <source>Aspire CLI Installations</source>
-        <target state="new">Aspire CLI Installations</target>
-        <note />
-      </trans-unit>
       <trans-unit id="InstallationDiscoveryFailedReason">
         <source>Install discovery failed. See the Aspire CLI logs for details.</source>
         <target state="new">Install discovery failed. See the Aspire CLI logs for details.</target>
@@ -222,41 +192,6 @@
         <target state="translated">摘要: {0} 個通過、{1} 個警告、{2} 個已失敗</target>
         <note />
       </trans-unit>
-      <trans-unit id="ValueCurrentMarker">
-        <source>(current)</source>
-        <target state="new">(current)</target>
-        <note>Suffix appended to the running CLI's path so the user can identify which install is themselves.</note>
-      </trans-unit>
-      <trans-unit id="ValueNotProbed">
-        <source>(not probed)</source>
-        <target state="new">(not probed)</target>
-        <note>Placeholder shown in the table when an install was found but not asked to self-describe (e.g., trust gate).</note>
-      </trans-unit>
-      <trans-unit id="ValuePathActive">
-        <source>active</source>
-        <target state="new">active</target>
-        <note>Shown when an install is the first Aspire CLI resolved from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathNotOnPath">
-        <source>not on PATH</source>
-        <target state="new">not on PATH</target>
-        <note>Shown when an install was not discovered from PATH.</note>
-      </trans-unit>
-      <trans-unit id="ValuePathShadowed">
-        <source>shadowed</source>
-        <target state="new">shadowed</target>
-        <note>Shown when an install is on PATH but an earlier Aspire CLI entry shadows it.</note>
-      </trans-unit>
-      <trans-unit id="ValueProbeFailed">
-        <source>(probe failed)</source>
-        <target state="new">(probe failed)</target>
-        <note>Placeholder shown in the table when an install was probed but did not return usable data.</note>
-      </trans-unit>
-      <trans-unit id="ValueUnknown">
-        <source>(unknown)</source>
-        <target state="new">(unknown)</target>
-        <note>Placeholder shown in the table when a field could not be determined for a discovered install.</note>
-      </trans-unit>
       <trans-unit id="VersionUnknown">
         <source>unknown</source>
         <target state="new">unknown</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.cs.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.cs.xlf
index 91c3eac67ef..887179ece3f 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.cs.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.cs.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Umožňuje potlačit banner spuštění a oznámení o telemetrii.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.de.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.de.xlf
index cd809a8985c..9e7a13c84ea 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.de.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.de.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Unterdrücken Sie das Startupbanner und den Telemetriehinweis.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.es.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.es.xlf
index 66b77a6fe83..ebeb53250c1 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.es.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.es.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Suprima el banner de inicio y el aviso de telemetría.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.fr.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.fr.xlf
index c843c706ff1..47abc53b6cc 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.fr.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.fr.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Supprimer la bannière de démarrage et la notification de télémétrie.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.it.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.it.xlf
index 40f3242c783..08d80ef7a1e 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.it.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.it.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Consente di disabilitare il banner di avvio e l'avviso di telemetria.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ja.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ja.xlf
index 1208fe7df5b..023214cec16 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ja.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ja.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">スタートアップ バナーとテレメトリ通知を非表示にします。</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ko.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ko.xlf
index e44b436e681..f953764c842 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ko.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ko.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">시작 배너 및 원격 분석 알림을 표시하지 않습니다.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pl.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pl.xlf
index fc53d7dbd71..d3afd616a7c 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pl.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pl.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Wstrzymaj baner startowy i powiadomienie o telemetrii.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pt-BR.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pt-BR.xlf
index 2eb0d6ffdfb..bbdb2d02cad 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pt-BR.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.pt-BR.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Suprima a faixa de inicialização e o aviso de telemetria.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ru.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ru.xlf
index 4f79109bcb1..4222643c1a9 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ru.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.ru.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Отключить баннер запуска и уведомление о телеметрии.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.tr.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.tr.xlf
index bfd7770297e..309050e1cde 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.tr.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.tr.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">Başlangıç başlığını ve telemetri bildirimini gizle.</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hans.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hans.xlf
index 5730a5874f3..e7a1988ae7c 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hans.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hans.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">抑制显示启动横幅和遥测通知。</target>
diff --git a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hant.xlf b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hant.xlf
index 7fac4df8fa5..ca8ccbc984c 100644
--- a/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hant.xlf
+++ b/src/Aspire.Cli/Resources/xlf/RootCommandStrings.zh-Hant.xlf
@@ -52,6 +52,21 @@ The Aspire CLI collects usage data. It is collected by Microsoft and is used to
 Read more about Aspire CLI telemetry: {0}</target>
         <note>{0} is a clickable URL</note>
       </trans-unit>
+      <trans-unit id="InfoArgumentDescription">
+        <source>Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</source>
+        <target state="new">Print the running CLI's version, channel, and the list of Aspire CLI installs discovered on this machine</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoFormatArgumentDescription">
+        <source>Output format for `--info`</source>
+        <target state="new">Output format for `--info`</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InfoOptionRequiresInfo">
+        <source>Option `{0}` is only valid when `--info` is also specified.</source>
+        <target state="new">Option `{0}` is only valid when `--info` is also specified.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoLogoArgumentDescription">
         <source>Suppress the startup banner and telemetry notice</source>
         <target state="needs-review-translation">抑制啟動橫幅與遙測通知。</target>
diff --git a/src/Aspire.Cli/Utils/EnvironmentChecker/EnvironmentCheckResult.cs b/src/Aspire.Cli/Utils/EnvironmentChecker/EnvironmentCheckResult.cs
index f699dbceff5..4fdd2920919 100644
--- a/src/Aspire.Cli/Utils/EnvironmentChecker/EnvironmentCheckResult.cs
+++ b/src/Aspire.Cli/Utils/EnvironmentChecker/EnvironmentCheckResult.cs
@@ -4,7 +4,6 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
-using Aspire.Cli.Acquisition;
 
 namespace Aspire.Cli.Utils.EnvironmentChecker;
 
@@ -133,12 +132,6 @@ internal sealed class DoctorCheckResponse
     /// </summary>
     [JsonPropertyName("summary")]
     public required DoctorCheckSummary Summary { get; set; }
-
-    /// <summary>
-    /// Gets or sets the discovered Aspire CLI installations.
-    /// </summary>
-    [JsonPropertyName("installations")]
-    public List<InstallationInfo>? Installations { get; set; }
 }
 
 /// <summary>
diff --git a/tests/Aspire.Cli.Tests/Acquisition/HiveEnumeratorTests.cs b/tests/Aspire.Cli.Tests/Acquisition/HiveEnumeratorTests.cs
new file mode 100644
index 00000000000..9ee37aede6a
--- /dev/null
+++ b/tests/Aspire.Cli.Tests/Acquisition/HiveEnumeratorTests.cs
@@ -0,0 +1,95 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Cli.Acquisition;
+using Aspire.Cli.Tests.Utils;
+
+namespace Aspire.Cli.Tests.Acquisition;
+
+public class HiveEnumeratorTests(ITestOutputHelper outputHelper)
+{
+    [Fact]
+    public void HasHive_ReturnsTrueForExistingValidChannel()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var context = workspace.CreateExecutionContext();
+        Directory.CreateDirectory(Path.Combine(context.HivesDirectory.FullName, "stable"));
+        Directory.CreateDirectory(Path.Combine(context.HivesDirectory.FullName, "pr-17400"));
+        var enumerator = new HiveEnumerator(context);
+
+        Assert.True(enumerator.HasHive("stable"));
+        Assert.True(enumerator.HasHive("pr-17400"));
+        Assert.False(enumerator.HasHive("daily"));
+    }
+
+    [Theory]
+    [InlineData("..")]
+    [InlineData("../escape")]
+    [InlineData("pr-17400/../../etc")]
+    [InlineData("/etc/passwd")]
+    [InlineData("C:\\Windows")]
+    [InlineData("pr-")]
+    [InlineData("pr-abc")]
+    [InlineData("Pr-17400")]
+    [InlineData("preview")]
+    [InlineData("")]
+    [InlineData("\0invalid")]
+    public void HasHive_RejectsChannelsOutsideIdentitySchema(string channel)
+    {
+        // HiveEnumerator must never feed a path-traversing, absolute, or
+        // otherwise malformed channel string into Path.Combine — channels can
+        // reach this surface via peer `--info --self` JSON, which is not
+        // shape-validated at the JSON layer. Anything outside the build-time
+        // identity-channel allow-list must be treated as "no hive".
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var context = workspace.CreateExecutionContext();
+        var enumerator = new HiveEnumerator(context);
+
+        Assert.False(enumerator.HasHive(channel));
+        Assert.Null(enumerator.GetHivePath(channel));
+    }
+
+    [Fact]
+    public void GetHivePath_ReturnsPathInsideHivesRootForValidChannel()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var context = workspace.CreateExecutionContext();
+        var enumerator = new HiveEnumerator(context);
+
+        var path = enumerator.GetHivePath("pr-17400");
+
+        Assert.NotNull(path);
+        Assert.StartsWith(context.HivesDirectory.FullName, path, StringComparison.Ordinal);
+        Assert.EndsWith("pr-17400", path, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void GetHives_ReturnsEmptyWhenHivesRootMissing()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var context = workspace.CreateExecutionContext();
+        var enumerator = new HiveEnumerator(context);
+
+        Assert.False(context.HivesDirectory.Exists);
+        Assert.Empty(enumerator.GetHives());
+    }
+
+    [Fact]
+    public void GetHives_EnumeratesUnvalidatedDirectoryNamesUnderHivesRoot()
+    {
+        // GetHives() walks the on-disk directory itself and only reports what's
+        // there — no channel-schema filtering. That's intentional: an orphan
+        // hive directory left behind by an older install script or a future
+        // channel name should still surface to the user via `aspire --info`.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var context = workspace.CreateExecutionContext();
+        Directory.CreateDirectory(Path.Combine(context.HivesDirectory.FullName, "pr-17400"));
+        Directory.CreateDirectory(Path.Combine(context.HivesDirectory.FullName, "future-channel"));
+        var enumerator = new HiveEnumerator(context);
+
+        var names = enumerator.GetHives().Select(h => h.Name).ToArray();
+
+        Assert.Contains("pr-17400", names);
+        Assert.Contains("future-channel", names);
+    }
+}
diff --git a/tests/Aspire.Cli.Tests/Acquisition/PeerInstallProbeTests.cs b/tests/Aspire.Cli.Tests/Acquisition/PeerInstallProbeTests.cs
index 8929dae096a..d41d54c8b62 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/PeerInstallProbeTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/PeerInstallProbeTests.cs
@@ -17,7 +17,7 @@ namespace Aspire.Cli.Tests.Acquisition;
 /// </summary>
 public class PeerInstallProbeTests(ITestOutputHelper outputHelper) : IDisposable
 {
-    // Route internal probe diagnostics (LogDebug for "JSON without an
+    // Forward internal probe diagnostics (LogDebug for "JSON without an
     // installation row", "invalid JSON", etc.) into the xunit test output
     // so a failure log tells us why the probe took whichever code path it
     // took. Keep the factory alive for the lifetime of the test class so
@@ -74,10 +74,10 @@ public async Task ProbeAsync_BinaryNotFound_ReturnsFailed()
     }
 
     [Fact]
-    public async Task ProbeAsync_InvokesPeerWithDoctorSelfFormatJson()
+    public async Task ProbeAsync_InvokesPeerWithInfoSelfFormatJson()
     {
         // The peer must be asked to describe ONLY itself. Without --self,
-        // `aspire doctor` would run full installation discovery and the peer would
+        // `aspire --info` would run full installation discovery and the peer would
         // recursively probe back into us — and into every other peer it
         // finds — turning a single discovery invocation into a fan-out bounded
         // only by the per-level timeout. `--format json` selects the
@@ -92,7 +92,7 @@ public async Task ProbeAsync_InvokesPeerWithDoctorSelfFormatJson()
         Assert.NotNull(fakePeer.ArgvFile);
         Assert.True(File.Exists(fakePeer.ArgvFile), $"Expected argv recorder file at {fakePeer.ArgvFile} to exist.");
         var argv = await File.ReadAllLinesAsync(fakePeer.ArgvFile, TestContext.Current.CancellationToken);
-        Assert.Equal(["doctor", "--self", "--format", "json"], argv);
+        Assert.Equal(["--info", "--self", "--format", "json"], argv);
     }
 
     [Fact]
@@ -109,7 +109,7 @@ public async Task ProbeAsync_PeerEmitsValidJsonArray_ReturnsOk()
                           "path": "/peer/aspire",
                           "version": "12.5.0",
                           "channel": "stable",
-                          "route": "script",
+                          "source": "script",
                           "pathStatus": "shadowed",
                           "status": "ok"
                         }
@@ -124,10 +124,43 @@ public async Task ProbeAsync_PeerEmitsValidJsonArray_ReturnsOk()
         var ok = AssertProbeOk(result);
         Assert.Equal("12.5.0", ok.Info.Version);
         Assert.Equal("stable", ok.Info.Channel);
-        Assert.Equal("script", ok.Info.Route);
+        Assert.Equal("script", ok.Info.Source);
         Assert.Equal(InstallationPathStatus.Shadowed, ok.Info.PathStatus);
     }
 
+    [Fact]
+    public async Task ProbeAsync_PeerEmitsBareInstallationArray_ReturnsOk()
+    {
+        // `aspire --info --self --format json` writes a bare array of
+        // InstallationInfo rows (see src/Aspire.Cli/Commands/InfoOptionAction.cs).
+        // The probe must accept that shape — not only the wrapped object form —
+        // so it stays compatible with new peers.
+        using var fakePeer = FakePeerScript.Build(
+            outputHelper,
+            stdout: """
+                    [
+                      {
+                        "path": "/peer/aspire",
+                        "version": "13.0.0",
+                        "channel": "pr-17400",
+                        "source": "pr",
+                        "pathStatus": "active",
+                        "status": "ok"
+                      }
+                    ]
+                    """,
+            exitCode: 0);
+
+        var probe = CreateProbeWithGenerousTimeout();
+        var result = await probe.ProbeAsync(fakePeer.Path, TestContext.Current.CancellationToken);
+
+        var ok = AssertProbeOk(result);
+        Assert.Equal("13.0.0", ok.Info.Version);
+        Assert.Equal("pr-17400", ok.Info.Channel);
+        Assert.Equal("pr", ok.Info.Source);
+        Assert.Equal(InstallationPathStatus.Active, ok.Info.PathStatus);
+    }
+
     [Fact]
     public async Task ProbeAsync_PeerOmitsPathStatus_DefaultsToNotOnPath()
     {
@@ -178,7 +211,7 @@ public async Task ProbeAsync_PeerEmitsInvalidPathStatus_DefaultsToNotOnPath()
     [Fact]
     public async Task ProbeAsync_PeerExitsNonZero_ReturnsFailedWhenVersionAlsoFails()
     {
-        // doctor path scripted to exit 7; --version not supported by this
+        // --info path scripted to exit 7; --version not supported by this
         // script (the default EmitExit body) → fallback path also fails
         // and the user sees the failure.
         using var fakePeer = FakePeerScript.Build(outputHelper, stdout: "{}", exitCode: 7);
@@ -262,8 +295,8 @@ public async Task ProbeAsync_PeerExitsNonZero_FallsBackToVersionAndReturnsPartia
 
         var ok = AssertProbeOk(result);
         Assert.Equal("13.4.0-pr.16817.g790d6fa3", ok.Info.Version);
-        // Fallback can't read route or channel from the older peer; the
-        // discovery layer overlays the route from the local sidecar.
+        // Fallback can't read source or channel from the older peer; the
+        // discovery layer overlays the source from the local sidecar.
         Assert.Null(ok.Info.Channel);
     }
 
@@ -290,7 +323,7 @@ public async Task ProbeAsync_BothInfoAndVersionFail_ReturnsFailed()
     [Fact]
     public async Task ProbeAsync_PeerEmitsEmptyArray_FallsBackToVersion()
     {
-        // Empty rich output is treated as "doctor didn't tell us anything useful"
+        // Empty rich output is treated as "--info didn't tell us anything useful"
         // and triggers the --version fallback. With no version response
         // scripted either, the overall probe fails.
         using var fakePeer = FakePeerScript.BuildDoctorOrVersion(
@@ -309,7 +342,7 @@ public async Task ProbeAsync_PeerEmitsEmptyArray_FallsBackToVersion()
     [Fact]
     public async Task ProbeAsync_PeerEmitsInvalidJson_FallsBackToVersion()
     {
-        // Invalid JSON on the doctor path is treated as a peer failure mode
+        // Invalid JSON on the --info path is treated as a peer failure mode
         // where the command emits help / error text, and triggers the
         // --version fallback.
         using var fakePeer = FakePeerScript.BuildDoctorOrVersion(
@@ -464,7 +497,7 @@ internal static class FakePeerScript
     /// Produces a script that writes <paramref name="stdout"/> verbatim
     /// and exits with <paramref name="exitCode"/>. The script dispatches on
     /// its first argument, so it works with both the probe's
-    /// <c>doctor --self --format json</c> invocation and the <c>--version</c>
+    /// <c>--info --self --format json</c> invocation and the <c>--version</c>
     /// fallback.
     /// </summary>
     internal static FakeScriptResult Build(ITestOutputHelper outputHelper, string stdout, int exitCode)
@@ -478,7 +511,7 @@ internal static FakeScriptResult Build(ITestOutputHelper outputHelper, string st
     }
 
     /// <summary>
-    /// Builds a script that responds differently to <c>doctor</c> vs
+    /// Builds a script that responds differently to <c>--info</c> vs
     /// <c>--version</c> arguments so PeerInstallProbeTests can exercise
     /// the rich-probe → version fallback path.
     /// </summary>
@@ -598,14 +631,14 @@ private sealed record EmitExit(string Stdout, string Stderr, int ExitCode) : Scr
         public override string RenderShell()
         {
             // The script behaves differently based on its first arg:
-            // - "doctor" → emit the scripted stdout and exit with the scripted code
+            // - "--info" → emit the scripted stdout and exit with the scripted code
             // - anything else (e.g. "--version") → emit nothing and exit 127
             // This lets PeerInstallProbeTests isolate the "rich probe failed"
             // case without the fallback `--version` accidentally succeeding
             // by virtue of the script ignoring its args.
             return $"""
                     #!/bin/sh
-                    if [ "$1" != "doctor" ]; then
+                    if [ "$1" != "--info" ]; then
                       exit 127
                     fi
                     cat <<'__ASPIRE_PEER_EOF__'
@@ -621,7 +654,7 @@ public override string RenderBatch()
             var lines = Stdout.Split('\n');
             var sb = new System.Text.StringBuilder();
             sb.AppendLine("@echo off");
-            sb.AppendLine("if not \"%~1\" == \"doctor\" exit /b 127");
+            sb.AppendLine("if not \"%~1\" == \"--info\" exit /b 127");
             foreach (var line in lines)
             {
                 sb.Append("echo ").AppendLine(line.TrimEnd('\r'));
@@ -637,7 +670,7 @@ private sealed record StderrRepeatScript(int ByteCount, int ExitCode) : ScriptBo
         public override string RenderShell() =>
             $"""
              #!/bin/sh
-             if [ "$1" != "doctor" ]; then
+             if [ "$1" != "--info" ]; then
                exit 127
              fi
              dd if=/dev/zero bs={ByteCount} count=1 2>/dev/null | LC_ALL=C tr '\000' 'x' 1>&2
@@ -648,7 +681,7 @@ public override string RenderBatch()
         {
             var sb = new StringBuilder();
             sb.AppendLine("@echo off");
-            sb.AppendLine("if not \"%~1\" == \"doctor\" exit /b 127");
+            sb.AppendLine("if not \"%~1\" == \"--info\" exit /b 127");
             sb.AppendLine($"powershell -NoProfile -ExecutionPolicy Bypass -Command \"[Console]::Error.Write(('x' * {ByteCount}))\"");
             sb.AppendLine($"exit /b {ExitCode}");
             return sb.ToString();
@@ -691,7 +724,7 @@ public override string RenderShell()
         {
             return $"""
                     #!/bin/sh
-                    if [ "$1" = "doctor" ]; then
+                    if [ "$1" = "--info" ]; then
                       cat <<'__ASPIRE_DOCTOR_EOF__'
                     {DoctorStdout}
                     __ASPIRE_DOCTOR_EOF__
@@ -711,7 +744,7 @@ public override string RenderBatch()
         {
             var sb = new System.Text.StringBuilder();
             sb.AppendLine("@echo off");
-            sb.AppendLine("if \"%~1\" == \"doctor\" goto :doctor");
+            sb.AppendLine("if \"%~1\" == \"--info\" goto :doctor");
             sb.AppendLine("if \"%~1\" == \"--version\" goto :version");
             sb.AppendLine("exit /b 127");
             sb.AppendLine(":doctor");
@@ -732,7 +765,7 @@ public override string RenderBatch()
 
     private sealed record ArgvRecorderScript(string ArgvFile) : ScriptBody
     {
-        // Minimal valid doctor JSON: enough for the probe to take the primary
+        // Minimal valid --info JSON: enough for the probe to take the primary
         // path (no fallback to --version), so the recorded argv reflects the
         // first invocation only.
         private const string DoctorJson = """{"checks":[],"summary":{"passed":0,"warnings":0,"failed":0},"installations":[{"path":"/peer/aspire","version":"1.0.0","status":"ok"}]}""";
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WindowsRegistryReaderTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WindowsRegistryReaderTests.cs
new file mode 100644
index 00000000000..2196249fca1
--- /dev/null
+++ b/tests/Aspire.Cli.Tests/Acquisition/WindowsRegistryReaderTests.cs
@@ -0,0 +1,264 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.Versioning;
+using Aspire.Cli.Acquisition;
+using Microsoft.Win32;
+
+namespace Aspire.Cli.Tests.Acquisition;
+
+/// <summary>
+/// Round-trip tests for <see cref="WindowsRegistryReader"/> against a real
+/// <c>HKCU\Software\Microsoft\Windows\CurrentVersion\Uninstall</c> hive. Each
+/// test writes a uniquely-named subkey, exercises the reader, and deletes the
+/// subkey in a <c>finally</c>. Crashed leftover subkeys are swept on next run
+/// by <see cref="TestUninstallEntry.SweepStaleEntries"/>.
+/// </summary>
+/// <remarks>
+/// All tests skip on non-Windows hosts via <see cref="Assert.SkipUnless(bool, string?)"/>.
+/// <see cref="SupportedOSPlatformAttribute"/> on each method also keeps the
+/// platform-compat analyzer (CA1416) happy for the <c>Microsoft.Win32</c> calls.
+/// </remarks>
+public class WindowsRegistryReaderTests
+{
+    static WindowsRegistryReaderTests()
+    {
+        // Defense in depth: if a previous test run was killed mid-test (CI
+        // timeout, OS reboot, etc.) the uninstall subkey will still be in HKCU.
+        // Sweep any "Microsoft.Aspire.Tests.*" leftovers before running so a
+        // stray entry can't cause an unrelated test to flake.
+        if (OperatingSystem.IsWindows())
+        {
+            TestUninstallEntry.SweepStaleEntries();
+        }
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_ReturnsTrue_WhenHkcuEntryMatches()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        using var binary = new TestTempDirectory();
+        var portableTarget = Path.Combine(binary.Path, "aspire.exe");
+        File.WriteAllBytes(portableTarget, []);
+
+        using var entry = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.Aspire",
+            portableTarget: portableTarget);
+
+        var reader = new WindowsRegistryReader();
+        Assert.True(reader.HasWingetAspireUninstallEntry(portableTarget));
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_ReturnsFalse_WhenIdentifierDoesNotMatch()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        using var binary = new TestTempDirectory();
+        var portableTarget = Path.Combine(binary.Path, "aspire.exe");
+        File.WriteAllBytes(portableTarget, []);
+
+        // Same shape as a real winget Aspire entry except the identifier is wrong.
+        // The reader must not match: it's specifically checking for "Microsoft.Aspire".
+        using var entry = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.NotAspire",
+            portableTarget: portableTarget);
+
+        var reader = new WindowsRegistryReader();
+        Assert.False(reader.HasWingetAspireUninstallEntry(portableTarget));
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_ReturnsFalse_WhenPortableTargetMissing()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        // A real Aspire winget portable install always writes PortableTargetFullPath;
+        // an entry that omits it is malformed and the reader must skip it rather
+        // than match on identifier alone.
+        using var entry = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.Aspire",
+            portableTarget: null);
+
+        var reader = new WindowsRegistryReader();
+        Assert.False(reader.HasWingetAspireUninstallEntry(@"C:\anything\aspire.exe"));
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_ReturnsFalse_WhenPortableTargetPointsElsewhere()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        using var binary = new TestTempDirectory();
+        var registeredTarget = Path.Combine(binary.Path, "aspire.exe");
+        var queriedTarget = Path.Combine(binary.Path, "different.exe");
+
+        using var entry = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.Aspire",
+            portableTarget: registeredTarget);
+
+        var reader = new WindowsRegistryReader();
+        Assert.False(reader.HasWingetAspireUninstallEntry(queriedTarget));
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_MatchesPathCaseInsensitively()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        // Windows filesystem paths are case-insensitive on NTFS by default. The
+        // reader documents OrdinalIgnoreCase comparison; this test pins that.
+        using var binary = new TestTempDirectory();
+        var registeredTarget = Path.Combine(binary.Path, "aspire.exe").ToLowerInvariant();
+        var queriedTarget = registeredTarget.ToUpperInvariant();
+
+        using var entry = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.Aspire",
+            portableTarget: registeredTarget);
+
+        var reader = new WindowsRegistryReader();
+        Assert.True(reader.HasWingetAspireUninstallEntry(queriedTarget));
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_ReturnsFalse_ForEmptyProcessPath()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        var reader = new WindowsRegistryReader();
+        Assert.False(reader.HasWingetAspireUninstallEntry(string.Empty));
+    }
+
+    [Fact]
+    [SupportedOSPlatform("windows")]
+    public void HasWingetAspireUninstallEntry_IgnoresUnrelatedEntries()
+    {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WindowsRegistryReader is Windows-only.");
+
+        // Surrounding the matching entry with unrelated identifier+target rows
+        // (mimicking the noisy real-world Uninstall hive) must not change the
+        // result. Both arms of the iterator are exercised: skip-on-identifier
+        // and skip-on-missing-target.
+        using var binary = new TestTempDirectory();
+        var portableTarget = Path.Combine(binary.Path, "aspire.exe");
+        File.WriteAllBytes(portableTarget, []);
+
+        using var unrelated1 = TestUninstallEntry.Create(
+            packageIdentifier: "Some.Other.Package",
+            portableTarget: portableTarget);
+        using var unrelated2 = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.Aspire",
+            portableTarget: null);
+        using var matching = TestUninstallEntry.Create(
+            packageIdentifier: "Microsoft.Aspire",
+            portableTarget: portableTarget);
+
+        var reader = new WindowsRegistryReader();
+        Assert.True(reader.HasWingetAspireUninstallEntry(portableTarget));
+    }
+}
+
+/// <summary>
+/// Creates a fake winget portable uninstall entry under
+/// <c>HKCU\Software\Microsoft\Windows\CurrentVersion\Uninstall</c> with a
+/// unique <c>Microsoft.Aspire.Tests.&lt;guid&gt;</c> subkey name, and deletes
+/// it on dispose. Static <see cref="SweepStaleEntries"/> removes any leftovers
+/// from crashed test runs so a stale entry can never affect a fresh run.
+/// </summary>
+file sealed class TestUninstallEntry : IDisposable
+{
+    private const string UninstallPath = @"Software\Microsoft\Windows\CurrentVersion\Uninstall";
+    // Distinctive prefix so leftover entries can be swept without affecting
+    // unrelated keys under Uninstall.
+    private const string TestSubKeyPrefix = "Microsoft.Aspire.Tests.";
+
+    private readonly string _subKeyName;
+
+    private TestUninstallEntry(string subKeyName)
+    {
+        _subKeyName = subKeyName;
+    }
+
+    [SupportedOSPlatform("windows")]
+    public static TestUninstallEntry Create(string packageIdentifier, string? portableTarget)
+    {
+        var subKeyName = TestSubKeyPrefix + Guid.NewGuid().ToString("N");
+
+        using var uninstall = Registry.CurrentUser.CreateSubKey(UninstallPath, writable: true)
+            ?? throw new InvalidOperationException($"Could not open or create HKCU\\{UninstallPath}.");
+        using var entry = uninstall.CreateSubKey(subKeyName, writable: true)
+            ?? throw new InvalidOperationException($"Could not create HKCU\\{UninstallPath}\\{subKeyName}.");
+
+        entry.SetValue("WinGetPackageIdentifier", packageIdentifier, RegistryValueKind.String);
+        if (portableTarget is not null)
+        {
+            entry.SetValue("PortableTargetFullPath", portableTarget, RegistryValueKind.String);
+        }
+
+        return new TestUninstallEntry(subKeyName);
+    }
+
+    public void Dispose()
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        TryDeleteSubKey(_subKeyName);
+    }
+
+    [SupportedOSPlatform("windows")]
+    public static void SweepStaleEntries()
+    {
+        try
+        {
+            using var uninstall = Registry.CurrentUser.OpenSubKey(UninstallPath, writable: true);
+            if (uninstall is null)
+            {
+                return;
+            }
+
+            foreach (var name in uninstall.GetSubKeyNames())
+            {
+                if (name.StartsWith(TestSubKeyPrefix, StringComparison.Ordinal))
+                {
+                    try
+                    {
+                        uninstall.DeleteSubKeyTree(name, throwOnMissingSubKey: false);
+                    }
+                    catch
+                    {
+                        // Best-effort sweep; tolerate per-entry deletion failure.
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // Best-effort sweep; tolerate the open failing entirely.
+        }
+    }
+
+    [SupportedOSPlatform("windows")]
+    private static void TryDeleteSubKey(string subKeyName)
+    {
+        try
+        {
+            using var uninstall = Registry.CurrentUser.OpenSubKey(UninstallPath, writable: true);
+            uninstall?.DeleteSubKeyTree(subKeyName, throwOnMissingSubKey: false);
+        }
+        catch
+        {
+            // Best-effort cleanup; stale entries are swept by the static
+            // constructor on the next run.
+        }
+    }
+}
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs
new file mode 100644
index 00000000000..d0f15468969
--- /dev/null
+++ b/tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs
@@ -0,0 +1,128 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Cli.Acquisition;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Aspire.Cli.Tests.Acquisition;
+
+/// <summary>
+/// Tests the startup-time invocation contract for <see cref="WingetFirstRunProbe"/>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The probe is fired exactly once from <see cref="Program.TryRunWingetFirstRunProbe(IServiceProvider)"/>,
+/// which is itself called from the <c>CliExecutionContext</c> DI singleton factory in
+/// <c>Program.BuildApplicationAsync</c>. The "factory invokes this helper" claim is a one-line
+/// code-review check at the factory body; the helper's own contract (resolves the probe, derives
+/// the binary directory from <see cref="Environment.ProcessPath"/>, swallows failures) is what is
+/// pinned here.
+/// </para>
+/// <para>
+/// The probe early-returns when the sidecar already exists at the target binary directory.
+/// In a normal test run the test host binary directory (the dotnet install root) carries no
+/// sidecar, but a stray sidecar would silently turn these tests into no-ops. Each test checks
+/// that precondition explicitly and skips with a diagnostic message otherwise.
+/// </para>
+/// </remarks>
+public class WingetStartupProbeTests
+{
+    [Fact]
+    public void TryRunWingetFirstRunProbe_InvokesProbeAgainstProcessBinaryDirectory()
+    {
+        AssertProbeReachableFromTestRunner();
+
+        var registry = new CapturingWindowsRegistryReader();
+        using var provider = BuildMinimalProvider(registry);
+
+        Program.TryRunWingetFirstRunProbe(provider);
+
+        // The probe reached the registry-check arm exactly once, which means it
+        // resolved WingetFirstRunProbe from DI, derived the binary directory from
+        // Environment.ProcessPath, found no pre-existing sidecar, and queried our
+        // capturing reader for ARP membership. Returning false from the reader
+        // also means no sidecar was written near the test runner's binary.
+        Assert.Equal(1, registry.CallCount);
+        Assert.Equal(Environment.ProcessPath, registry.LastProcessPath);
+    }
+
+    [Fact]
+    public void TryRunWingetFirstRunProbe_SwallowsRegistryReaderException()
+    {
+        AssertProbeReachableFromTestRunner();
+
+        using var provider = BuildMinimalProvider(new ThrowingWindowsRegistryReader());
+
+        // No exception must escape: a registry probe failure during CLI startup
+        // is logged and treated as "not a winget install for this run", not a
+        // fatal error that prevents the CLI from launching.
+        var ex = Record.Exception(() => Program.TryRunWingetFirstRunProbe(provider));
+        Assert.Null(ex);
+    }
+
+    /// <summary>
+    /// Skips the test if <see cref="Environment.ProcessPath"/> is unavailable or
+    /// if a stray <c>.aspire-install.json</c> exists at the test host's binary
+    /// directory. Either condition would make the probe early-return before
+    /// reaching the registry reader, which would silently invalidate the assertion.
+    /// </summary>
+    private static void AssertProbeReachableFromTestRunner()
+    {
+        var processPath = Environment.ProcessPath;
+        Assert.SkipUnless(
+            !string.IsNullOrEmpty(processPath),
+            "Environment.ProcessPath is unavailable in this test host; the startup probe cannot run.");
+
+        var binaryDir = Path.GetDirectoryName(processPath);
+        Assert.SkipUnless(
+            !string.IsNullOrEmpty(binaryDir),
+            $"Could not derive a binary directory from Environment.ProcessPath='{processPath}'.");
+
+        var sidecarPath = Path.Combine(binaryDir, ".aspire-install.json");
+        Assert.SkipUnless(
+            !File.Exists(sidecarPath),
+            $"Test host binary directory '{binaryDir}' already contains '{InstallSidecarReader.SidecarFileName}'; the probe would early-return before consulting the registry. " +
+            "Remove the stray sidecar or run the tests from a different host to exercise this scenario.");
+    }
+
+    private static ServiceProvider BuildMinimalProvider(IWindowsRegistryReader registry)
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton(registry);
+        // WingetFirstRunProbe's constructor takes ILogger<WingetFirstRunProbe>, so the
+        // registration must be against the interface — registering the concrete
+        // NullLogger<T> alone would leave DI unable to resolve the ctor parameter,
+        // and the outer try/catch in TryRunWingetFirstRunProbe would silently swallow
+        // the resolution failure instead of reaching the registry probe.
+        services.AddSingleton<ILogger<WingetFirstRunProbe>>(NullLogger<WingetFirstRunProbe>.Instance);
+        services.AddSingleton<WingetFirstRunProbe>();
+        return services.BuildServiceProvider();
+    }
+}
+
+/// <summary>
+/// Captures every <see cref="HasWingetAspireUninstallEntry"/> call and always
+/// returns <see langword="false"/> so the probe does not write a sidecar near
+/// the test host's binary.
+/// </summary>
+file sealed class CapturingWindowsRegistryReader : IWindowsRegistryReader
+{
+    private int _callCount;
+    public int CallCount => Volatile.Read(ref _callCount);
+    public string? LastProcessPath { get; private set; }
+
+    public bool HasWingetAspireUninstallEntry(string processPath)
+    {
+        Interlocked.Increment(ref _callCount);
+        LastProcessPath = processPath;
+        return false;
+    }
+}
+
+file sealed class ThrowingWindowsRegistryReader : IWindowsRegistryReader
+{
+    public bool HasWingetAspireUninstallEntry(string processPath)
+        => throw new InvalidOperationException("Simulated registry probe failure for test.");
+}
diff --git a/tests/Aspire.Cli.Tests/Commands/DoctorCommandTests.cs b/tests/Aspire.Cli.Tests/Commands/DoctorCommandTests.cs
index b91cda7c8b5..cf3fdae0289 100644
--- a/tests/Aspire.Cli.Tests/Commands/DoctorCommandTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/DoctorCommandTests.cs
@@ -567,7 +567,7 @@ public async Task DoctorCommand_Json_CliVersion_IncludesLatestVersionChannel_Whe
     }
 
     [Fact]
-    public async Task DoctorCommand_Json_IncludesDiscoveredInstallations()
+    public async Task DoctorCommand_Json_DoesNotIncludeDiscoveredInstallations()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         using var doc = await RunDoctorJsonAsync(workspace,
@@ -583,7 +583,7 @@ public async Task DoctorCommand_Json_IncludesDiscoveredInstallations()
                     CanonicalPath = "/home/test/.aspire/bin/aspire",
                     Version = "13.0.0",
                     Channel = "stable",
-                    Route = "script",
+                    Source = "script",
                     PathStatus = InstallationPathStatus.Active,
                     Status = InstallationInfoStatus.Ok,
                 },
@@ -595,99 +595,17 @@ public async Task DoctorCommand_Json_IncludesDiscoveredInstallations()
                         CanonicalPath = "/home/test/.aspire/dogfood/pr-1234/bin/aspire",
                         Version = "13.1.0-preview",
                         Channel = "pr-1234",
-                        Route = "pr",
+                        Source = "pr",
                         PathStatus = InstallationPathStatus.Shadowed,
                         Status = InstallationInfoStatus.Ok,
-                    },
-                ]));
-
-        var installations = doc.RootElement.GetProperty("installations").EnumerateArray().ToArray();
-        Assert.Equal(2, installations.Length);
-
-        var self = installations[0];
-        Assert.Equal("/home/test/.aspire/bin/aspire", self.GetProperty("path").GetString());
-        Assert.Equal("stable", self.GetProperty("channel").GetString());
-        Assert.Equal("script", self.GetProperty("route").GetString());
-        Assert.Equal(InstallationPathStatus.Active, self.GetProperty("pathStatus").GetString());
-
-        var peer = installations[1];
-        Assert.Equal("/home/test/.aspire/dogfood/pr-1234/bin/aspire", peer.GetProperty("path").GetString());
-        Assert.Equal("pr-1234", peer.GetProperty("channel").GetString());
-        Assert.Equal("pr", peer.GetProperty("route").GetString());
-        Assert.Equal(InstallationPathStatus.Shadowed, peer.GetProperty("pathStatus").GetString());
-    }
+                     },
+                 ]));
 
-    [Fact]
-    public async Task DoctorCommand_HumanReadable_Self_RendersOnlyRunningInstallationAndSkipsChecks()
-    {
-        // `doctor --self` is the peer-probe surface. Without --format the
-        // human-readable table is the default; with --format json the
-        // probe gets a machine-readable row. Either way, no environment
-        // checks run and only the running CLI's row is rendered.
-        using var workspace = TemporaryWorkspace.Create(outputHelper);
-        var output = new StringWriter();
-        var console = AnsiConsole.Create(new AnsiConsoleSettings
-        {
-            Ansi = AnsiSupport.No,
-            ColorSystem = ColorSystemSupport.NoColors,
-            Interactive = InteractionSupport.No,
-            Out = new AnsiConsoleOutput(output),
-            Enrichment = new ProfileEnrichment { UseDefaultEnrichers = false },
-        });
-        console.Profile.Width = int.MaxValue;
-
-        var services = CreateDoctorVersionServiceCollection(workspace, outputHelper, options =>
-        {
-            options.CliUpdateNotifierFactory = _ => new TestCliUpdateNotifier();
-        });
-        services.RemoveAll<IAnsiConsole>();
-        services.AddSingleton<IAnsiConsole>(console);
-        UseFakeInstallationDiscovery(
-            services,
-            self: new InstallationInfo
-            {
-                Path = "/home/test/.aspire/bin/aspire",
-                CanonicalPath = "/home/test/.aspire/bin/aspire",
-                Version = "13.4.0-pr.17115.gcd700928",
-                Channel = "pr-17115",
-                Route = "brew",
-                PathStatus = InstallationPathStatus.Active,
-                Status = InstallationInfoStatus.Ok,
-            },
-            others:
-            [
-                new InstallationInfo
-                {
-                    Path = "/peer/aspire",
-                    CanonicalPath = "/peer/aspire",
-                    Version = "13.1.0-preview",
-                    Channel = "pr-1234",
-                    Route = "pr",
-                    PathStatus = InstallationPathStatus.Shadowed,
-                    Status = InstallationInfoStatus.Ok,
-                },
-            ]);
-
-        using var provider = services.BuildServiceProvider();
-        var command = provider.GetRequiredService<Aspire.Cli.Commands.RootCommand>();
-        var result = command.Parse("doctor --self");
-
-        var exitCode = await result.InvokeAsync().DefaultTimeout();
-
-        Assert.Equal(CliExitCodes.Success, exitCode);
-        var rendered = output.ToString();
-        Assert.Contains("Aspire CLI Installations", rendered, StringComparison.Ordinal);
-        Assert.Contains("13.4.0-pr.17115.gcd700928", rendered, StringComparison.Ordinal);
-        Assert.Contains("pr-17115", rendered, StringComparison.Ordinal);
-        // No environment checks ran, so no Summary line.
-        Assert.DoesNotContain("Summary:", rendered, StringComparison.Ordinal);
-        // No peer rows — --self bounds the output to the running CLI only.
-        Assert.DoesNotContain("/peer/aspire", rendered, StringComparison.Ordinal);
-        Assert.DoesNotContain("pr-1234", rendered, StringComparison.Ordinal);
+        Assert.False(doc.RootElement.TryGetProperty("installations", out _));
     }
 
     [Fact]
-    public async Task DoctorCommand_HumanReadable_AppendsInstallationsAfterSummary()
+    public async Task DoctorCommand_HumanReadable_DoesNotAppendInstallationsAfterSummary()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var output = new StringWriter();
@@ -715,7 +633,7 @@ public async Task DoctorCommand_HumanReadable_AppendsInstallationsAfterSummary()
                 CanonicalPath = "/home/test/.aspire/bin/aspire",
                 Version = "13.0.0",
                 Channel = "stable",
-                Route = "script",
+                Source = "script",
                 PathStatus = InstallationPathStatus.Active,
                 Status = InstallationInfoStatus.Ok,
             },
@@ -727,7 +645,7 @@ public async Task DoctorCommand_HumanReadable_AppendsInstallationsAfterSummary()
                     CanonicalPath = "/peer/aspire",
                     Version = "13.1.0-preview",
                     Channel = "pr-1234",
-                    Route = "pr",
+                    Source = "pr",
                     PathStatus = InstallationPathStatus.Shadowed,
                     Status = InstallationInfoStatus.Ok,
                 },
@@ -741,107 +659,35 @@ public async Task DoctorCommand_HumanReadable_AppendsInstallationsAfterSummary()
 
         Assert.Equal(CliExitCodes.Success, exitCode);
         var rendered = output.ToString();
-        var summaryIndex = rendered.IndexOf("Summary:", StringComparison.Ordinal);
-        var installationsIndex = rendered.IndexOf("Aspire CLI Installations", StringComparison.Ordinal);
-        Assert.True(summaryIndex >= 0, $"Expected doctor summary in output:{Environment.NewLine}{rendered}");
-        Assert.True(installationsIndex > summaryIndex, $"Expected installations after summary in output:{Environment.NewLine}{rendered}");
-        Assert.Contains("/peer/aspire", rendered, StringComparison.Ordinal);
-        Assert.Contains("pr-1234", rendered, StringComparison.Ordinal);
+        Assert.Contains("Summary:", rendered, StringComparison.Ordinal);
+        Assert.DoesNotContain("Aspire CLI Installations", rendered, StringComparison.Ordinal);
+        Assert.DoesNotContain("/peer/aspire", rendered, StringComparison.Ordinal);
+        Assert.DoesNotContain("pr-1234", rendered, StringComparison.Ordinal);
     }
 
     [Fact]
-    public async Task DoctorCommand_HumanReadable_EscapesUnknownPathStatus()
+    public void DoctorCommand_InfoCommandIsNotRegistered()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
-        var output = new StringWriter();
-        var console = AnsiConsole.Create(new AnsiConsoleSettings
-        {
-            Ansi = AnsiSupport.No,
-            ColorSystem = ColorSystemSupport.NoColors,
-            Interactive = InteractionSupport.No,
-            Out = new AnsiConsoleOutput(output),
-            Enrichment = new ProfileEnrichment { UseDefaultEnrichers = false },
-        });
-        console.Profile.Width = int.MaxValue;
-
-        // pathStatus is parsed from untrusted peer-probe stdout. A peer
-        // that emits an unrecognized string must not be able to inject
-        // Spectre markup into the parent's rendered table; the default
-        // branch of PathStatusDisplay must EscapeMarkup() the value.
-        var services = CreateDoctorVersionServiceCollection(workspace, outputHelper, options =>
-        {
-            options.CliUpdateNotifierFactory = _ => new TestCliUpdateNotifier();
-        });
-        services.RemoveAll<IAnsiConsole>();
-        services.AddSingleton<IAnsiConsole>(console);
-        UseFakeInstallationDiscovery(
-            services,
-            self: new InstallationInfo
-            {
-                Path = "/home/test/.aspire/bin/aspire",
-                CanonicalPath = "/home/test/.aspire/bin/aspire",
-                Version = "13.0.0",
-                Channel = "stable",
-                Route = "script",
-                PathStatus = "custom[red]status[/]",
-                Status = InstallationInfoStatus.Ok,
-            });
-
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
         using var provider = services.BuildServiceProvider();
-        var command = provider.GetRequiredService<Aspire.Cli.Commands.RootCommand>();
-        var result = command.Parse("doctor");
 
-        var exitCode = await result.InvokeAsync().DefaultTimeout();
+        var command = provider.GetRequiredService<Aspire.Cli.Commands.RootCommand>();
 
-        Assert.Equal(CliExitCodes.Success, exitCode);
-        var rendered = output.ToString();
-        Assert.Contains("custom[red]status[/]", rendered, StringComparison.Ordinal);
+        Assert.DoesNotContain(command.Subcommands, subcommand => subcommand.Name == "info");
     }
 
     [Fact]
-    public void DoctorCommand_InfoCommandIsNotRegistered()
+    public void DoctorCommand_Self_IsNotRegistered()
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
         using var provider = services.BuildServiceProvider();
 
         var command = provider.GetRequiredService<Aspire.Cli.Commands.RootCommand>();
+        var result = command.Parse("doctor --self --format json");
 
-        Assert.DoesNotContain(command.Subcommands, subcommand => subcommand.Name == "info");
-    }
-
-    [Fact]
-    public async Task DoctorCommand_Json_Self_ReturnsOnlyRunningInstallation()
-    {
-        using var workspace = TemporaryWorkspace.Create(outputHelper);
-        using var doc = await RunDoctorJsonAsync(workspace,
-            commandLine: "doctor --self --format json",
-            configureOptions: options =>
-            {
-                options.CliUpdateNotifierFactory = _ => new TestCliUpdateNotifier();
-            },
-            configureServices: services => UseFakeInstallationDiscovery(
-                services,
-                self: new InstallationInfo
-                {
-                    Path = "/usr/local/bin/aspire",
-                    CanonicalPath = "/usr/local/bin/aspire",
-                    Version = "13.0.0",
-                    Channel = "stable",
-                    Route = "script",
-                    PathStatus = InstallationPathStatus.Active,
-                    Status = InstallationInfoStatus.Ok,
-                }));
-
-        Assert.Empty(doc.RootElement.GetProperty("checks").EnumerateArray());
-        var installations = doc.RootElement.GetProperty("installations").EnumerateArray().ToArray();
-        var row = Assert.Single(installations);
-        Assert.Equal("/usr/local/bin/aspire", row.GetProperty("path").GetString());
-        Assert.Equal("13.0.0", row.GetProperty("version").GetString());
-        Assert.Equal("stable", row.GetProperty("channel").GetString());
-        Assert.Equal("script", row.GetProperty("route").GetString());
-        Assert.Equal(InstallationPathStatus.Active, row.GetProperty("pathStatus").GetString());
-        Assert.Equal(InstallationInfoStatus.Ok, row.GetProperty("status").GetString());
+        Assert.NotEmpty(result.Errors);
     }
 
     [Fact]
@@ -863,72 +709,7 @@ public async Task DoctorCommand_Json_WhenInstallDiscoveryFails_StillReturnsDocto
                 discoverAllException: new IOException("PATH lookup failed")));
 
         Assert.NotEmpty(doc.RootElement.GetProperty("checks").EnumerateArray());
-        var row = Assert.Single(doc.RootElement.GetProperty("installations").EnumerateArray());
-        Assert.Equal(InstallationInfoStatus.Failed, row.GetProperty("status").GetString());
-        Assert.Equal("Install discovery failed. See the Aspire CLI logs for details.", row.GetProperty("statusReason").GetString());
-    }
-
-    [Theory]
-    [InlineData(InstallationInfoStatus.Failed, "(probe failed)")]
-    [InlineData(InstallationInfoStatus.NotProbed, "(not probed)")]
-    [InlineData(InstallationInfoStatus.Ok, "(unknown)")]
-    public async Task DoctorCommand_HumanReadable_RendersMissingInstallationValuesBasedOnStatus(string status, string expectedPlaceholder)
-    {
-        using var workspace = TemporaryWorkspace.Create(outputHelper);
-        var output = new StringWriter();
-        var console = AnsiConsole.Create(new AnsiConsoleSettings
-        {
-            Ansi = AnsiSupport.No,
-            ColorSystem = ColorSystemSupport.NoColors,
-            Interactive = InteractionSupport.No,
-            Out = new AnsiConsoleOutput(output),
-            Enrichment = new ProfileEnrichment { UseDefaultEnrichers = false },
-        });
-        console.Profile.Width = int.MaxValue;
-
-        var services = CreateDoctorVersionServiceCollection(workspace, outputHelper, options =>
-        {
-            options.CliUpdateNotifierFactory = _ => new TestCliUpdateNotifier();
-        });
-        services.RemoveAll<IAnsiConsole>();
-        services.AddSingleton<IAnsiConsole>(console);
-        UseFakeInstallationDiscovery(
-            services,
-            self: new InstallationInfo
-            {
-                Path = "/home/test/.aspire/bin/aspire",
-                CanonicalPath = "/home/test/.aspire/bin/aspire",
-                Version = "13.0.0",
-                Channel = "stable",
-                Route = "script",
-                PathStatus = InstallationPathStatus.Active,
-                Status = InstallationInfoStatus.Ok,
-            },
-            others:
-            [
-                new InstallationInfo
-                {
-                    Path = $"/peer/{status}/aspire",
-                    CanonicalPath = $"/peer/{status}/aspire",
-                    Status = status,
-                },
-            ]);
-        using var provider = services.BuildServiceProvider();
-
-        var command = provider.GetRequiredService<Aspire.Cli.Commands.RootCommand>();
-        var result = command.Parse("doctor");
-
-        var exitCode = await result.InvokeAsync().DefaultTimeout();
-        Assert.Equal(CliExitCodes.Success, exitCode);
-
-        var rendered = output.ToString();
-        Assert.Contains($"/peer/{status}/aspire", rendered, StringComparison.Ordinal);
-        Assert.Contains(expectedPlaceholder, rendered, StringComparison.Ordinal);
-
-        foreach (var otherPlaceholder in new[] { "(probe failed)", "(not probed)", "(unknown)" }.Where(p => p != expectedPlaceholder))
-        {
-            Assert.DoesNotContain(otherPlaceholder, rendered, StringComparison.Ordinal);
-        }
+        Assert.False(doc.RootElement.TryGetProperty("installations", out _));
     }
 
     // Centralizes the scaffolding shared by `doctor --format json` tests:
@@ -992,7 +773,7 @@ private static IServiceCollection CreateDoctorVersionServiceCollection(
                 CanonicalPath = "/test/aspire",
                 Version = "13.0.0",
                 Channel = "stable",
-                Route = "script",
+                Source = "script",
                 PathStatus = InstallationPathStatus.Active,
                 Status = InstallationInfoStatus.Ok,
             });
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
new file mode 100644
index 00000000000..917a5426655
--- /dev/null
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -0,0 +1,750 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Cli.Acquisition;
+using Aspire.Cli.Commands;
+using Aspire.Cli.Tests.TestServices;
+using Aspire.Cli.Tests.Utils;
+using Microsoft.AspNetCore.InternalTesting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using System.Text.Json.Nodes;
+
+namespace Aspire.Cli.Tests.Commands;
+
+public class InfoOptionTests(ITestOutputHelper outputHelper)
+{
+    [Fact]
+    public void Info_IsInformationalOption_SoFirstRunNoticeAndTelemetryAreSuppressed()
+    {
+        // Wired via CommonOptionNames so DisplayFirstTimeUseNoticeIfNeededAsync
+        // does not print the banner or consume the one-shot sentinel and the
+        // telemetry manager opts out for `aspire --info` (the text form is the
+        // path not covered by HasMachineReadableOutputFormat).
+        Assert.Contains(CommonOptionNames.Info, CommonOptionNames.InformationalOptionNames);
+    }
+
+    [Fact]
+    public async Task Info_Self_Json_ReturnsOnlyRunningInstallationAsArray()
+    {
+        // Cross-version peer-probe contract: PeerInstallProbe.TryParseRichProbeResult
+        // expects a bare array of InstallationInfo, not the wrapped object form.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/usr/local/bin/aspire",
+                CanonicalPath = "/usr/local/bin/aspire",
+                Version = "13.0.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            },
+            [
+                new InstallationInfo
+                {
+                    Path = "/peer/aspire",
+                    CanonicalPath = "/peer/aspire",
+                    Version = "13.1.0-preview",
+                    Channel = "pr-1234",
+                    Source = "pr",
+                    PathStatus = InstallationPathStatus.Shadowed,
+                    Status = InstallationInfoStatus.Ok,
+                }
+            ])));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --self --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var installations = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsArray();
+        var row = Assert.Single(installations);
+        Assert.Equal("/usr/local/bin/aspire", row!["path"]!.GetValue<string>());
+        Assert.Equal("13.0.0", row["version"]!.GetValue<string>());
+        Assert.Equal("stable", row["channel"]!.GetValue<string>());
+        Assert.Equal("script", row["source"]!.GetValue<string>());
+        Assert.Equal(InstallationPathStatus.Active, row["pathStatus"]!.GetValue<string>());
+        Assert.Equal(InstallationInfoStatus.Ok, row["status"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public async Task Info_Self_Text_ReturnsOnlyRunningInstallationWithoutChecks()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/usr/local/bin/aspire",
+                Version = "13.0.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = "custom[red]status[/]",
+                Status = InstallationInfoStatus.Ok,
+            },
+            [
+                new InstallationInfo
+                {
+                    Path = "/peer/aspire",
+                    Status = InstallationInfoStatus.Ok,
+                }
+            ])));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --self");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var output = string.Join(Environment.NewLine, outputWriter.Logs);
+        Assert.Contains("/usr/local/bin/aspire", output, StringComparison.Ordinal);
+        Assert.Contains("custom[red]status[/]", output, StringComparison.Ordinal);
+        Assert.DoesNotContain("/peer/aspire", output, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task Info_Text_ShowsDiscoveredInstallsAndOrphanHives()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        Directory.CreateDirectory(Path.Combine(aspireHome, "hives", "pr-17400", "packages"));
+
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Version = "13.2.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var output = string.Join(Environment.NewLine, outputWriter.Logs);
+        Assert.Contains("script", output);
+        Assert.Contains("stable", output);
+        Assert.Contains("orphan-hive", output);
+        Assert.Contains("pr-17400", output);
+        Assert.Contains("no install found", output);
+        Assert.DoesNotContain("│", output);
+    }
+
+    [Fact]
+    public async Task Info_FormatList_IsAcceptedAndUsesVerticalOutput()
+    {
+        // `--format list` is the explicit spelling of the default text rendering.
+        // Carried from the previous installs surface so existing automation that
+        // sets `--format list` doesn't break, and to anchor the enum so arbitrary
+        // values like `table` are rejected by the System.CommandLine value parser.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Version = "13.2.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format list");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var output = string.Join(Environment.NewLine, outputWriter.Logs);
+        Assert.DoesNotContain("│", output);
+    }
+
+    [Fact]
+    public void Info_FormatTable_IsRejected()
+    {
+        // Anchor the enum: `table` is not a valid value, so the parser must
+        // reject it rather than silently fall through.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format table");
+
+        Assert.NotEmpty(result.Errors);
+    }
+
+    [Fact]
+    public async Task Info_FailedRow_DoesNotDuplicateReasonAcrossStatusAndReasonFields()
+    {
+        // The structured `status` field must stay enum-shaped ("failed",
+        // "notProbed", "active", ...) — the human-readable message rides on
+        // `statusReason` alone. Concatenating the two would (a) force JSON
+        // consumers to split on ": " before they can `switch` on status and
+        // (b) make the human surface print the reason twice (once in the
+        // Status line, once in the Reason line). Guarded for both the JSON
+        // and the human surfaces.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/peer/aspire",
+                CanonicalPath = "/peer/aspire",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Shadowed,
+                Status = InstallationInfoStatus.Failed,
+                StatusReason = "timed out after 5s"
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+
+        var listExitCode = await command.Parse("--info").InvokeAsync().DefaultTimeout();
+        Assert.Equal(CliExitCodes.Success, listExitCode);
+        var listOutput = string.Join(Environment.NewLine, outputWriter.Logs);
+        Assert.Contains("Status   failed", listOutput);
+        Assert.DoesNotContain("Status   failed:", listOutput);
+        Assert.Contains("Reason   timed out after 5s", listOutput);
+
+        outputWriter.Logs.Clear();
+
+        var jsonExitCode = await command.Parse("--info --format json").InvokeAsync().DefaultTimeout();
+        Assert.Equal(CliExitCodes.Success, jsonExitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        var row = payload["installs"]!.AsArray()[0]!;
+        Assert.Equal("failed", row["status"]!.GetValue<string>());
+        Assert.Equal("timed out after 5s", row["statusReason"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public async Task Info_Json_IncludesDiscoveredInstallsBrokenRowsAndOrphanHives()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        Directory.CreateDirectory(Path.Combine(aspireHome, "hives", "pr-17400", "packages"));
+
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Version = "13.2.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok
+            },
+            [
+                new InstallationInfo
+                {
+                    Path = Path.Combine(aspireHome, "broken", "aspire"),
+                    CanonicalPath = Path.Combine(aspireHome, "broken", "aspire"),
+                    Channel = "daily",
+                    Source = "script",
+                    PathStatus = InstallationPathStatus.Shadowed,
+                    Status = InstallationInfoStatus.Failed,
+                    StatusReason = "peer probe failed"
+                }
+            ])));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        Assert.NotNull(payload["version"]);
+        Assert.Equal("13.2.0", payload["version"]!.GetValue<string>());
+        var installs = payload["installs"]!.AsArray();
+        Assert.Collection(
+            installs,
+            row =>
+            {
+                Assert.Equal("script", row!["id"]!.GetValue<string>());
+                Assert.Equal("script", row["kind"]!.GetValue<string>());
+                Assert.Equal("stable", row["channel"]!.GetValue<string>());
+                Assert.Equal("active", row["status"]!.GetValue<string>());
+            },
+            row =>
+            {
+                Assert.Equal("script-2", row!["id"]!.GetValue<string>());
+                Assert.Equal("failed", row["status"]!.GetValue<string>());
+                Assert.Equal("peer probe failed", row["statusReason"]!.GetValue<string>());
+            },
+            row =>
+            {
+                Assert.Equal("pr-17400", row!["id"]!.GetValue<string>());
+                Assert.Equal("orphan-hive", row["kind"]!.GetValue<string>());
+                Assert.Equal("no install found", row["status"]!.GetValue<string>());
+            });
+    }
+
+    [Fact]
+    public async Task Info_DiscoveryWalkFails_StillExitsZero_AndEmitsFailureRow()
+    {
+        // Matches the tolerant posture of the channel-read and self-version
+        // paths: `aspire --info` is the surface a user reaches for to
+        // diagnose a flaky environment, so a discovery walk that throws
+        // (filesystem ACL, IO error on ~/.aspire/hives, ...) must not crash
+        // the command. Exit 0, surface a single failure row with the
+        // underlying reason in statusReason, keep channel/version intact.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/usr/local/bin/aspire",
+                Channel = "stable",
+                Status = InstallationInfoStatus.Ok,
+            },
+            discoverAllException: new IOException("PATH lookup failed"))));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        var installs = payload["installs"]!.AsArray();
+        var row = Assert.Single(installs);
+        Assert.Equal("discovery", row!["id"]!.GetValue<string>());
+        Assert.Equal("discovery-failed", row["kind"]!.GetValue<string>());
+        Assert.Equal(InstallationInfoStatus.Failed, row["status"]!.GetValue<string>());
+        Assert.Equal("PATH lookup failed", row["statusReason"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public async Task Info_Json_EmptyInstalls_StillEmitsArray()
+    {
+        // When discovery returns nothing, the installs field must still appear
+        // (as an empty array) so consumers don't need a "missing or empty"
+        // branch.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                // The self row carries a non-aspire filename and no source, so
+                // IsDisplayableInstall filters it out.
+                Path = "/opt/homebrew/Cellar/dotnet/10.0.0/libexec/dotnet",
+                CanonicalPath = "/opt/homebrew/Cellar/dotnet/10.0.0/libexec/dotnet",
+                Channel = "local",
+                Source = null,
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        var installs = payload["installs"]!.AsArray();
+        Assert.Empty(installs);
+    }
+
+    [Fact]
+    public async Task Info_ChannelLocal_IsNotTreatedAsFailure()
+    {
+        // "local" is the developer-build default. It must serialize as
+        // "channel": "local", not be dropped or mapped to null.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IIdentityChannelReader>(_ => new ConstantChannelReader("local")));
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/local/aspire",
+                CanonicalPath = "/local/aspire",
+                Version = "13.2.0",
+                Channel = "local",
+                Source = "localhive",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        Assert.Equal("local", payload["channel"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public async Task Info_ChannelReadFailure_ExitsZero_AndOmitsChannel()
+    {
+        // A binary with missing/invalid AspireCliChannel assembly metadata must
+        // not take `aspire --info` down with it — that's the surface a user
+        // reaches for to *find out* their binary is broken. The channel field
+        // is omitted from JSON (via DefaultIgnoreCondition.WhenWritingNull)
+        // and the text row is skipped, but the command still exits 0.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IIdentityChannelReader>(_ => new ThrowingChannelReader()));
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/broken/aspire",
+                CanonicalPath = "/broken/aspire",
+                Version = "13.2.0",
+                Channel = null,
+                Source = "script",
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        // CliExecutionContext must still resolve even though the channel
+        // reader throws — the production DI factory defers the read via
+        // Lazy<string> and InfoOptionAction injects IIdentityChannelReader
+        // directly with its own try/catch. Locks the lazy-channel refactor in.
+        _ = provider.GetRequiredService<CliExecutionContext>();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        Assert.False(payload.ContainsKey("channel"));
+    }
+
+    [Fact]
+    public async Task Info_ChannelReadFailure_Text_OmitsChannelLine()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IIdentityChannelReader>(_ => new ThrowingChannelReader()));
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/broken/aspire",
+                CanonicalPath = "/broken/aspire",
+                Version = "13.2.0",
+                Channel = null,
+                Source = "script",
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var output = string.Join(Environment.NewLine, outputWriter.Logs);
+        Assert.Contains("Version  13.2.0", output);
+        Assert.DoesNotContain("Channel  ", output);
+    }
+
+    [Fact]
+    public async Task Info_LogsClassificationReasons()
+    {
+        // Operational logs from the row-builder are operationally important
+        // for diagnosing why a peer is missing or extra. Carried from the
+        // previous installs surface.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        Directory.CreateDirectory(Path.Combine(aspireHome, "hives", "pr-17400", "packages"));
+        var logger = new CapturingLogger<InfoOptionAction>();
+
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        services.Replace(ServiceDescriptor.Singleton<ILogger<InfoOptionAction>>(logger));
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/opt/homebrew/Cellar/dotnet/10.0.107/libexec/dotnet",
+                CanonicalPath = "/opt/homebrew/Cellar/dotnet/10.0.107/libexec/dotnet",
+                Version = "13.2.0",
+                Channel = "local",
+                Source = null,
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.Ok
+            },
+            [
+                new InstallationInfo
+                {
+                    Path = Path.Combine(aspireHome, "bin", "aspire"),
+                    CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                    Version = "13.2.0",
+                    Channel = "local",
+                    Source = "localhive",
+                    PathStatus = InstallationPathStatus.Active,
+                    Status = InstallationInfoStatus.Ok
+                }
+            ])));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        Assert.Contains(logger.Entries, e => e.Level == LogLevel.Debug && e.Message.Contains("Ignoring discovery row path", StringComparison.Ordinal));
+        Assert.Contains(logger.Entries, e => e.Level == LogLevel.Debug && e.Message.Contains("Classified install path", StringComparison.Ordinal) && e.Message.Contains("localhive", StringComparison.Ordinal));
+        Assert.Contains(logger.Entries, e => e.Level == LogLevel.Debug && e.Message.Contains("Classified hive", StringComparison.Ordinal) && e.Message.Contains("orphan", StringComparison.Ordinal));
+    }
+
+    [Fact]
+    public void Info_SelfWithoutInfo_FailsParse()
+    {
+        // The --self modifier is only meaningful when --info is also set.
+        // Without the validator, `aspire --self` would silently fall through
+        // to grouped help with InvalidCommand and look like a no-op.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--self");
+
+        Assert.NotEmpty(result.Errors);
+    }
+
+    [Fact]
+    public void Info_FormatWithoutInfo_FailsParse()
+    {
+        // The --format modifier is only meaningful when --info is also set.
+        // Without the validator, the root-level --format could swallow a
+        // value intended for a subcommand option (e.g. `--format json doctor`
+        // would parse as a root-level --format=json followed by an unrelated
+        // doctor subcommand).
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--format json");
+
+        Assert.NotEmpty(result.Errors);
+    }
+
+    [Fact]
+    public void Doctor_FormatJson_StillParsesAsSubcommandOption()
+    {
+        // Regression guard: the new root-level --format must not break
+        // existing `doctor --format json` invocations. Doctor declares its
+        // own --format option; the validator on the root-level --format
+        // gates that to require --info, so this token is consumed by the
+        // doctor subcommand instead.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("doctor --format json");
+
+        Assert.Empty(result.Errors);
+    }
+
+    [Fact]
+    public void Info_OnSubcommand_DoesNotFireInfoAction()
+    {
+        // `aspire run --info` is *separate from* `aspire --info`: --info is
+        // root-only (not recursive), so when supplied on a subcommand it does
+        // not bind to the root option, the InfoOptionAction does not fire,
+        // and the subcommand's normal parse runs. This keeps install
+        // enumeration a deliberate top-level operation and avoids the
+        // recursive-option / subcommand-local --format shadowing trap, where
+        // `aspire run --info --format json` would otherwise silently emit
+        // install text because run's own --format swallows the token.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("run --info");
+
+        // --info supplied on the subcommand does not bind to the root option.
+        // GetValue returns the option default (false), proving the
+        // InfoOptionAction wouldn't fire for this parse.
+        Assert.False(result.GetValue(command.InfoOption));
+        // The parse selects the `run` subcommand instead of the root.
+        Assert.NotNull(result.CommandResult);
+        Assert.NotSame(command, result.CommandResult.Command);
+    }
+
+    [Fact]
+    public void Info_OnSubcommand_WithFormat_BindsFormatToSubcommand()
+    {
+        // Companion to Info_OnSubcommand_DoesNotFireInfoAction: with --info
+        // non-recursive, the trailing `--format json` after a subcommand
+        // also doesn't bind to root's InfoFormatOption, so there's no
+        // root-level --format value lingering after parse. Run's own
+        // --format option still owns the token; this test pins that
+        // routing so a future change to InfoFormatOption recursion can't
+        // silently resurrect the shadowing bug where `aspire run --info
+        // --format json` looked like it should emit info JSON but actually
+        // ran the subcommand with `--format=json`.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper);
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("run --info --format json");
+
+        Assert.False(result.GetValue(command.InfoOption));
+        // Root-level InfoFormatOption sees its default (List), confirming
+        // the `--format json` token did not bind here.
+        Assert.Equal(InfoOutputFormat.List, result.GetValue(command.InfoFormatOption));
+    }
+
+    [Fact]
+    public async Task Info_Self_Json_IsParseableByInstallationInfoParser_PeerProbeContract()
+    {
+        // End-to-end self-loop on the cross-version peer-probe contract:
+        // drive the action with `--info --self --format json`, capture
+        // stdout, and feed it through InstallationInfoParser.Parse — the
+        // same code path PeerInstallProbe.TryParseRichProbeResult uses to
+        // shape a peer's response. Without this test, a future refactor
+        // of InstallationInfoOutput.DescribeSelfSafely or the JSON source
+        // generation context could silently drift the wire shape away from
+        // what the parser expects, and the existing PeerInstallProbeTests
+        // script fakes wouldn't catch it because they hard-code the JSON
+        // shape in the script.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/peer/aspire",
+                CanonicalPath = "/peer/aspire",
+                Version = "13.7.0-pr.17999.gabc12345",
+                Channel = "pr-17999",
+                Source = "pr",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --self --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+        Assert.Equal(CliExitCodes.Success, exitCode);
+
+        var stdout = string.Join(Environment.NewLine, outputWriter.Logs);
+        using var doc = System.Text.Json.JsonDocument.Parse(stdout);
+        Assert.Equal(System.Text.Json.JsonValueKind.Array, doc.RootElement.ValueKind);
+        Assert.Equal(1, doc.RootElement.GetArrayLength());
+
+        // Feed through the production peer-probe parser. Any drift in
+        // property names, casing, or shape will fail here.
+        var parsed = InstallationInfoParser.Parse(doc.RootElement[0]);
+        Assert.Equal("/peer/aspire", parsed.Path);
+        Assert.Equal("/peer/aspire", parsed.CanonicalPath);
+        Assert.Equal("13.7.0-pr.17999.gabc12345", parsed.Version);
+        Assert.Equal("pr-17999", parsed.Channel);
+        Assert.Equal("pr", parsed.Source);
+        Assert.Equal(InstallationPathStatus.Active, parsed.PathStatus);
+        Assert.Equal(InstallationInfoStatus.Ok, parsed.Status);
+    }
+
+    private sealed class ConstantChannelReader(string channel) : IIdentityChannelReader
+    {
+        public string ReadChannel() => channel;
+    }
+
+    private sealed class ThrowingChannelReader : IIdentityChannelReader
+    {
+        public string ReadChannel() => throw new InvalidOperationException("AspireCliChannel assembly metadata is missing.");
+    }
+}
diff --git a/tests/Aspire.Cli.Tests/Commands/SetupCommandTests.cs b/tests/Aspire.Cli.Tests/Commands/SetupCommandTests.cs
index e5c2e481254..62fddff99a0 100644
--- a/tests/Aspire.Cli.Tests/Commands/SetupCommandTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/SetupCommandTests.cs
@@ -6,12 +6,12 @@
 namespace Aspire.Cli.Tests.Commands;
 
 // `SetupCommand.GetDefaultInstallPath` returns parent-of-binary regardless of
-// install route — distinct from the route-aware `BundleService.GetDefaultExtractDir`
-// used by auto-extract. These tests pin the route-independent contract.
+// install source — distinct from the source-aware `BundleService.GetDefaultExtractDir`
+// used by auto-extract. These tests pin the source-independent contract.
 public class SetupCommandTests
 {
     [Fact]
-    public void GetDefaultInstallPath_ScriptRouteLayout_ReturnsParentOfBinaryDirectory()
+    public void GetDefaultInstallPath_ScriptSourceLayout_ReturnsParentOfBinaryDirectory()
     {
         var processPath = Path.Combine("home", ".aspire", "bin", "aspire");
 
@@ -21,7 +21,7 @@ public void GetDefaultInstallPath_ScriptRouteLayout_ReturnsParentOfBinaryDirecto
     }
 
     [Fact]
-    public void GetDefaultInstallPath_PRRouteLayout_ReturnsParentOfBinaryDirectory()
+    public void GetDefaultInstallPath_PRSourceLayout_ReturnsParentOfBinaryDirectory()
     {
         var processPath = Path.Combine("home", ".aspire", "dogfood", "pr-12345", "bin", "aspire");
 
@@ -31,9 +31,9 @@ public void GetDefaultInstallPath_PRRouteLayout_ReturnsParentOfBinaryDirectory()
     }
 
     [Fact]
-    public void GetDefaultInstallPath_ManagedRouteFlatLayout_ReturnsParentOfBinaryDirectory()
+    public void GetDefaultInstallPath_ManagedSourceFlatLayout_ReturnsParentOfBinaryDirectory()
     {
-        // Managed-route layout is flat (no bin/ subdir). `BundleService.GetDefaultExtractDir`
+        // Managed-source layout is flat (no bin/ subdir). `BundleService.GetDefaultExtractDir`
         // diverges here and keeps the payload inside the binary's dir so package-manager uninstall reaches it.
         var processPath = Path.Combine("Program Files", "WindowsApps", "Microsoft.Aspire_xyz", "aspire.exe");
 
diff --git a/tests/Aspire.Cli.Tests/Configuration/DotNetBasedAppHostServerChannelResolutionTests.cs b/tests/Aspire.Cli.Tests/Configuration/DotNetBasedAppHostServerChannelResolutionTests.cs
index f9365c651b8..e0801887199 100644
--- a/tests/Aspire.Cli.Tests/Configuration/DotNetBasedAppHostServerChannelResolutionTests.cs
+++ b/tests/Aspire.Cli.Tests/Configuration/DotNetBasedAppHostServerChannelResolutionTests.cs
@@ -18,7 +18,7 @@ namespace Aspire.Cli.Tests.Configuration;
 /// per-project channel is set. A global-channel read fallback (previously
 /// <c>IConfigurationService.GetConfigurationAsync("channel", ...)</c>) was removed in
 /// PR1; these tests pin the post-fix contract so a regression can't quietly re-introduce
-/// cross-route channel contamination.
+/// cross-source channel contamination.
 /// </summary>
 public class DotNetBasedAppHostServerChannelResolutionTests(ITestOutputHelper outputHelper)
 {
diff --git a/tests/Aspire.Cli.Tests/Packaging/TemporaryNuGetConfigTests.cs b/tests/Aspire.Cli.Tests/Packaging/TemporaryNuGetConfigTests.cs
index dcf8d9305fa..e9230348024 100644
--- a/tests/Aspire.Cli.Tests/Packaging/TemporaryNuGetConfigTests.cs
+++ b/tests/Aspire.Cli.Tests/Packaging/TemporaryNuGetConfigTests.cs
@@ -141,7 +141,7 @@ public async Task CreateAsync_PackageSourceAddKeyMatchesPackageSourceMappingKey(
         // will accept after its own internal canonicalization (e.g. on macOS the
         // upstream caller must strip /private/var → /var before constructing the
         // PackageMapping — see CliPathHelper.StripMacOSFirmlinkPrefix and the
-        // GetAspireHomeDirectory_OnMacOS_PrRouteWithFirmlinkedProcessPath test).
+        // GetAspireHomeDirectory_OnMacOS_PrSourceWithFirmlinkedProcessPath test).
         // This test only pins the writer's symmetry contract.
         var mappings = new PackageMapping[]
         {
diff --git a/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs b/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs
index 628238e9f0e..4d8e2fc0c12 100644
--- a/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs
+++ b/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs
@@ -256,6 +256,7 @@ public static IServiceCollection CreateServiceCollection(TemporaryWorkspace work
         services.AddTransient<TelemetryTracesCommand>();
         services.AddTransient<ExportCommand>();
         services.AddTransient<ExtensionInternalCommand>();
+        services.AddTransient<InfoOptionAction>();
         services.AddTransient<WaitCommand>();
         services.AddTransient<RestoreCommand>();
         services.AddTransient<SdkCommand>();
@@ -280,6 +281,7 @@ public static IServiceCollection CreateServiceCollection(TemporaryWorkspace work
         services.AddTransient<RenderCommand>();
 #endif
         services.AddTransient(options.AppHostBackchannelFactory);
+        services.AddTransient<HiveEnumerator>();
 
         return services;
     }

From 3c6d5a0e25a1ef0abf9031cecbf4c859839b8fb5 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 26 May 2026 20:07:32 -0400
Subject: [PATCH 04/15] fix(cli): make --info informational gate position-aware
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous gate scanned raw args with
`args.Any(a => InformationalOptionNames.Contains(a))`. Because `--info`
is wired as a root-only non-recursive option on `RootCommand`,
`aspire run --info` is a real `run` invocation — the `--info` token
does not bind to `RootCommand.InfoOption`. But the position-blind scan
still matched the literal token, so `aspire run --info` silently
suppressed telemetry, suppressed the first-run banner, and skipped
creating the one-shot first-run sentinel for that real `run`
invocation.

Replace `InformationalOptionNames` with `IsInformationalInvocation`, a
position-aware helper:

  - `--info` counts as informational only before the first non-option
    token (matching the System.CommandLine binding).
  - `--version`, `--help`, `-h`, `-?` stay position-blind because
    System.CommandLine treats them as recursive — they really are
    informational at any depth, e.g. `aspire run --help`.

`TelemetryManager` and `Program.DisplayFirstTimeUseNoticeIfNeededAsync`
both switch to the helper. Test coverage pins both sides of the new
contract:

  - `Info_OnSubcommand_IsNotInformationalInvocation` /
    `RecursiveInformationalFlags_OnSubcommand_RemainInformational` —
    helper-level.
  - `AzureMonitor_Disabled_WhenInfoFlagProvided` /
    `AzureMonitor_Enabled_WhenInfoFlagOnSubcommand` /
    `AzureMonitor_Disabled_WhenRecursiveInformationalFlagOnSubcommand`
    — telemetry-gate behavior.
  - `InfoFlagOnSubcommand_CreatesSentinelAndShowsBanner_OnFirstRun` /
    `RecursiveInformationalFlag_OnSubcommand_DoesNotCreateSentinel`
    — first-run sentinel / banner behavior.
  - `--info` added to the existing
    `InformationalFlag_SuppressesBannerAndDoesNotCreateSentinel`
    theory for symmetry with `--version`/`--help`.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Aspire.Cli/CommonOptionNames.cs           | 63 +++++++++++++++++--
 src/Aspire.Cli/Program.cs                     |  5 +-
 src/Aspire.Cli/Telemetry/TelemetryManager.cs  |  4 +-
 .../Commands/InfoOptionTests.cs               | 47 ++++++++++++--
 .../Commands/RootCommandTests.cs              | 61 ++++++++++++++++++
 .../Telemetry/TelemetryConfigurationTests.cs  | 43 +++++++++++++
 6 files changed, 209 insertions(+), 14 deletions(-)

diff --git a/src/Aspire.Cli/CommonOptionNames.cs b/src/Aspire.Cli/CommonOptionNames.cs
index 8d80e1586df..081ee44318b 100644
--- a/src/Aspire.Cli/CommonOptionNames.cs
+++ b/src/Aspire.Cli/CommonOptionNames.cs
@@ -24,11 +24,62 @@ internal static class CommonOptionNames
     public const string StartDebugSession = "--start-debug-session";
 
     /// <summary>
-    /// Options that represent informational commands (e.g. --version, --help, --info) which
-    /// should opt out of telemetry and suppress the first-run experience. `--info` is included
-    /// because its text form does not consume a `--format json` token (handled separately by
-    /// <c>HasMachineReadableOutputFormat</c>) but must not consume the one-shot first-run sentinel
-    /// or start a tracked telemetry activity.
+    /// Returns <c>true</c> when <paramref name="args"/> represents an informational invocation
+    /// (an invocation whose primary effect is to print diagnostic / version / help / install
+    /// information rather than run a user command) and which should therefore opt out of
+    /// telemetry, suppress the first-run banner, and skip consuming the one-shot first-run
+    /// sentinel.
     /// </summary>
-    public static readonly string[] InformationalOptionNames = [Version, Help, HelpShort, HelpAlt, Info];
+    /// <remarks>
+    /// <para>
+    /// <c>--version</c>, <c>--help</c>, <c>-h</c>, and <c>-?</c> are recursive in
+    /// System.CommandLine — they bind at any depth — so they really are informational at any
+    /// position (e.g. <c>aspire run --help</c> is genuinely a help invocation, not a
+    /// <c>run</c> invocation).
+    /// </para>
+    /// <para>
+    /// <c>--info</c>, by contrast, is intentionally wired as a root-only non-recursive option
+    /// on <c>RootCommand</c>. <c>aspire --info</c> fires the info action; <c>aspire run --info</c>
+    /// runs the <c>run</c> subcommand with an unmatched <c>--info</c> token. This helper mirrors
+    /// that binding: <c>--info</c> is treated as informational only when it appears before any
+    /// subcommand token in <paramref name="args"/>. Otherwise <c>aspire run --info</c> would
+    /// silently suppress telemetry and skip the first-run sentinel for a real <c>run</c>
+    /// invocation.
+    /// </para>
+    /// <para>
+    /// The first non-option token (one that does not start with <c>-</c>) is treated as the
+    /// subcommand boundary. A pathological case like <c>aspire --format json --info</c> — where
+    /// an option value happens to look like a subcommand — would short-circuit the <c>--info</c>
+    /// check; in practice the root-level <c>--format</c> validator rejects that parse anyway
+    /// when it's not paired with <c>--info</c>.
+    /// </para>
+    /// </remarks>
+    public static bool IsInformationalInvocation(string[]? args)
+    {
+        if (args is null)
+        {
+            return false;
+        }
+
+        var sawSubcommand = false;
+        foreach (var arg in args)
+        {
+            if (!sawSubcommand && arg == Info)
+            {
+                return true;
+            }
+
+            if (arg is Version or Help or HelpShort or HelpAlt)
+            {
+                return true;
+            }
+
+            if (!sawSubcommand && arg.Length > 0 && arg[0] != '-')
+            {
+                sawSubcommand = true;
+            }
+        }
+
+        return false;
+    }
 }
diff --git a/src/Aspire.Cli/Program.cs b/src/Aspire.Cli/Program.cs
index e7b218488bc..3f6851f6b67 100644
--- a/src/Aspire.Cli/Program.cs
+++ b/src/Aspire.Cli/Program.cs
@@ -731,7 +731,10 @@ private static IConfigurationService BuildConfigurationService(IServiceProvider
     internal static async Task DisplayFirstTimeUseNoticeIfNeededAsync(IServiceProvider serviceProvider, string[] args, CancellationToken cancellationToken = default)
     {
         var configuration = serviceProvider.GetRequiredService<IConfiguration>();
-        var isInformationalCommand = args.Any(a => CommonOptionNames.InformationalOptionNames.Contains(a));
+        // Position-aware: --info is root-only (non-recursive), so `aspire run --info` does
+        // not bind to RootCommand.InfoOption and is a real `run` invocation. It must still
+        // create the first-run sentinel and show the banner.
+        var isInformationalCommand = CommonOptionNames.IsInformationalInvocation(args);
         var isMachineReadableOutput = HasMachineReadableOutputFormat(args);
         var noLogo = args.Any(a => a == CommonOptionNames.NoLogo)
             || configuration.GetBool(CliConfigNames.NoLogo, defaultValue: false)
diff --git a/src/Aspire.Cli/Telemetry/TelemetryManager.cs b/src/Aspire.Cli/Telemetry/TelemetryManager.cs
index f23e33396f1..89afa74d563 100644
--- a/src/Aspire.Cli/Telemetry/TelemetryManager.cs
+++ b/src/Aspire.Cli/Telemetry/TelemetryManager.cs
@@ -59,7 +59,9 @@ internal sealed class TelemetryManager : IDisposable
     public TelemetryManager(IConfiguration configuration, string[]? args = null)
     {
         // Don't send telemetry for informational commands or if the user has opted out.
-        var hasOptOutArg = args?.Any(a => CommonOptionNames.InformationalOptionNames.Contains(a)) ?? false;
+        // Position-aware so `aspire run --info` (a real `run` invocation; --info is root-only
+        // non-recursive) stays subject to telemetry instead of being silently opted out.
+        var hasOptOutArg = CommonOptionNames.IsInformationalInvocation(args);
         var telemetryOptOut = hasOptOutArg || configuration.GetBool(AspireCliTelemetry.TelemetryOptOutConfigKey, defaultValue: false);
 
         var profilingEnabled =
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index 917a5426655..abd70496846 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -16,13 +16,48 @@ namespace Aspire.Cli.Tests.Commands;
 public class InfoOptionTests(ITestOutputHelper outputHelper)
 {
     [Fact]
-    public void Info_IsInformationalOption_SoFirstRunNoticeAndTelemetryAreSuppressed()
+    public void Info_IsInformationalInvocation_SoFirstRunNoticeAndTelemetryAreSuppressed()
     {
-        // Wired via CommonOptionNames so DisplayFirstTimeUseNoticeIfNeededAsync
-        // does not print the banner or consume the one-shot sentinel and the
-        // telemetry manager opts out for `aspire --info` (the text form is the
-        // path not covered by HasMachineReadableOutputFormat).
-        Assert.Contains(CommonOptionNames.Info, CommonOptionNames.InformationalOptionNames);
+        // Wired via CommonOptionNames.IsInformationalInvocation so
+        // DisplayFirstTimeUseNoticeIfNeededAsync does not print the banner or
+        // consume the one-shot sentinel and the telemetry manager opts out for
+        // `aspire --info` (the text form is the path not covered by
+        // HasMachineReadableOutputFormat).
+        Assert.True(CommonOptionNames.IsInformationalInvocation([CommonOptionNames.Info]));
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["--info", "--self"]));
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["--info", "--format", "json"]));
+    }
+
+    [Theory]
+    [InlineData("run", "--info")]
+    [InlineData("run", "apphost.csproj", "--info")]
+    [InlineData("new", "--info")]
+    [InlineData("publish", "--info", "--format", "json")]
+    public void Info_OnSubcommand_IsNotInformationalInvocation(params string[] args)
+    {
+        // --info is wired as a root-only non-recursive option on RootCommand
+        // (see Info_OnSubcommand_DoesNotFireInfoAction). A subcommand
+        // invocation that happens to carry `--info` is a real subcommand
+        // invocation, not an info invocation, and must not silently opt out
+        // of telemetry or skip the one-shot first-run sentinel.
+        Assert.False(CommonOptionNames.IsInformationalInvocation(args));
+    }
+
+    [Theory]
+    [InlineData("run", "--help")]
+    [InlineData("run", "-h")]
+    [InlineData("run", "-?")]
+    [InlineData("run", "--version")]
+    [InlineData("publish", "manifest", "--help")]
+    public void RecursiveInformationalFlags_OnSubcommand_RemainInformational(params string[] args)
+    {
+        // Companion to Info_OnSubcommand_IsNotInformationalInvocation: unlike
+        // --info, --help / --version / -h / -? are recursive in
+        // System.CommandLine — they bind at any depth and genuinely turn the
+        // invocation into a help/version action. The gate must keep treating
+        // them as informational anywhere they appear, otherwise we'd start
+        // creating the first-run sentinel for `aspire run --help`.
+        Assert.True(CommonOptionNames.IsInformationalInvocation(args));
     }
 
     [Fact]
diff --git a/tests/Aspire.Cli.Tests/Commands/RootCommandTests.cs b/tests/Aspire.Cli.Tests/Commands/RootCommandTests.cs
index 58dd58b444c..764281a6495 100644
--- a/tests/Aspire.Cli.Tests/Commands/RootCommandTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/RootCommandTests.cs
@@ -365,6 +365,7 @@ public async Task Banner_TelemetryNoticeNotShownOnSubsequentRuns()
     [InlineData("--help")]
     [InlineData("-h")]
     [InlineData("-?")]
+    [InlineData("--info")]
     public async Task InformationalFlag_SuppressesBannerAndDoesNotCreateSentinel(string flag)
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
@@ -413,6 +414,66 @@ public async Task InformationalFlag_DoesNotCreateSentinel_OnSubsequentFirstRun()
         Assert.True(sentinel.WasCreated);
     }
 
+    [Theory]
+    [InlineData("run", "--info")]
+    [InlineData("new", "--info")]
+    [InlineData("publish", "--info")]
+    public async Task InfoFlagOnSubcommand_CreatesSentinelAndShowsBanner_OnFirstRun(params string[] args)
+    {
+        // Companion to InformationalFlag_SuppressesBannerAndDoesNotCreateSentinel:
+        // --info is root-only / non-recursive (see InfoOptionTests'
+        // Info_OnSubcommand_DoesNotFireInfoAction), so `aspire run --info` is a
+        // real `run` invocation. The first-run gate must therefore create the
+        // sentinel and show the banner instead of silently consuming the
+        // one-shot first-run slot for what looks like an informational invocation.
+        // (Machine-readable invocations like `publish --info --format json` still
+        // suppress banner+sentinel via the separate HasMachineReadableOutputFormat
+        // gate; that's not the path this test pins.)
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var sentinel = new TestFirstTimeUseNoticeSentinel { SentinelExists = false };
+        var bannerService = new TestBannerService();
+
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.FirstTimeUseNoticeSentinelFactory = _ => sentinel;
+            options.BannerServiceFactory = _ => bannerService;
+            options.CliHostEnvironmentFactory = _ => TestHelpers.CreateInteractiveHostEnvironment();
+        });
+        using var provider = services.BuildServiceProvider();
+
+        await Program.DisplayFirstTimeUseNoticeIfNeededAsync(provider, args);
+
+        Assert.True(bannerService.WasBannerDisplayed);
+        Assert.True(sentinel.WasCreated);
+    }
+
+    [Theory]
+    [InlineData("run", "--help")]
+    [InlineData("run", "--version")]
+    [InlineData("publish", "manifest", "--help")]
+    public async Task RecursiveInformationalFlag_OnSubcommand_DoesNotCreateSentinel(params string[] args)
+    {
+        // Recursive informational options (--help / --version / -h / -?) bind at
+        // any depth in System.CommandLine. The first-run gate must keep treating
+        // them as informational at any position to avoid `aspire run --help`
+        // silently consuming the one-shot first-run slot.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var sentinel = new TestFirstTimeUseNoticeSentinel { SentinelExists = false };
+        var bannerService = new TestBannerService();
+
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.FirstTimeUseNoticeSentinelFactory = _ => sentinel;
+            options.BannerServiceFactory = _ => bannerService;
+        });
+        using var provider = services.BuildServiceProvider();
+
+        await Program.DisplayFirstTimeUseNoticeIfNeededAsync(provider, args);
+
+        Assert.False(bannerService.WasBannerDisplayed);
+        Assert.False(sentinel.WasCreated);
+    }
+
     [Fact]
     public async Task FirstTimeUseNotice_BannerNotDisplayedInNonInteractiveEnvironment()
     {
diff --git a/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs b/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs
index 9eaadbe2137..f14873b5754 100644
--- a/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs
+++ b/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs
@@ -186,6 +186,49 @@ public void AzureMonitor_Disabled_ForAllHelpFlags(string flag)
         Assert.False(manager.HasAzureMonitor);
     }
 
+    [Fact]
+    public void AzureMonitor_Disabled_WhenInfoFlagProvided()
+    {
+        var configuration = new ConfigurationBuilder().Build();
+
+        var manager = new TelemetryManager(configuration, ["--info"]);
+
+        Assert.False(manager.HasAzureMonitor);
+    }
+
+    [Theory]
+    [InlineData("run", "--info")]
+    [InlineData("new", "--info")]
+    [InlineData("publish", "--info", "--format", "json")]
+    public void AzureMonitor_Enabled_WhenInfoFlagOnSubcommand(params string[] args)
+    {
+        // --info is intentionally root-only / non-recursive (see InfoOptionTests'
+        // Info_OnSubcommand_DoesNotFireInfoAction). A subcommand invocation that
+        // carries --info is a real subcommand invocation, so reported telemetry
+        // must not be silently opted out for it.
+        var configuration = new ConfigurationBuilder().Build();
+
+        var manager = new TelemetryManager(configuration, args);
+
+        Assert.True(manager.HasAzureMonitor);
+    }
+
+    [Theory]
+    [InlineData("run", "--help")]
+    [InlineData("run", "--version")]
+    [InlineData("publish", "manifest", "--help")]
+    public void AzureMonitor_Disabled_WhenRecursiveInformationalFlagOnSubcommand(params string[] args)
+    {
+        // --help / --version are recursive in System.CommandLine, so e.g.
+        // `aspire run --help` is genuinely a help invocation. The gate must
+        // keep opting out of telemetry for them at any depth.
+        var configuration = new ConfigurationBuilder().Build();
+
+        var manager = new TelemetryManager(configuration, args);
+
+        Assert.False(manager.HasAzureMonitor);
+    }
+
     private static ActivityListener CreateActivityListener(string sourceName)
     {
         var listener = new ActivityListener

From 2860545dbc1e7dcde225fef2d0e06e2603662206 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 26 May 2026 22:30:04 -0400
Subject: [PATCH 05/15] refactor(cli): unify aspire --info JSON wire shape

Before this change `aspire --info --format json` and
`aspire --info --self --format json` returned two structurally different
record types:

  - aggregate `installs[*]` was an `InstallListItem` with
    {id, kind, channel, path, hive, status, statusReason, managedBy}
  - `--self` bare-array element was an `InstallationInfo` with
    {path, canonicalPath, version, channel, source, pathStatus, status,
     statusReason}

Only 4 of ~10 fields overlapped. Neither shape has shipped (the
introducing PR #17105 commit is not in any release tag or release branch),
so there is no backward-compat constraint here.

Unify both surfaces onto `InstallationInfo`:

  - `Path` becomes nullable (orphan-hive rows describe a directory on disk
    with no binary).
  - Add `Id`, `Kind`, `Hive`, `ManagedBy` to `InstallationInfo`. Aggregate
    rows populate them; the `--self` surface leaves them null (and
    `WhenWritingNull` keeps them out of the JSON).
  - Delete the `InstallListItem` record.
  - `InfoOutput.Installs` is now `IReadOnlyList<InstallationInfo>`.
  - Drop the `GetInstallStatus` projection that previously folded
    `PathStatus` into `Status` for OK aggregate rows. `Status` is now
    purely lifecycle (`ok`/`failed`/`notProbed`/`no install found`) and
    `PathStatus` is the PATH-axis on both surfaces. The two axes are
    orthogonal on the wire.
  - Text rendering now emits `Status   <lifecycle>` plus
    `On PATH  <pathStatus>` for the aggregate, mirroring what `--self`
    already did.

Contract + behavior tests:

  - `Info_UnifiedShape_AggregateRowAndSelfRowHaveSameKeys` pins that the
    aggregate and self surfaces use the same record shape.
  - `Info_Json_StatusAndPathStatusAreOrthogonalForOkInstalls` catches
    accidental re-introduction of the status/pathStatus projection.
  - `Info_Json_OrphanHiveRow_HasNullPathAndPopulatedHive` pins the
    orphan-hive structural shape.
  - `Info_Json_SortOrder_ActiveThenShadowedThenNotOnPathThenFailedThenOrphanHive`
    pins the deterministic row order under the new orthogonal axes.
  - `Info_TextRendering_DisplaysStatusAndOnPathSeparately` pins the
    human-visible two-line rendering.

The existing `Info_Self_Json_IsParseableByInstallationInfoParser_PeerProbeContract`
roundtrip test continues to pin the peer-probe wire contract end-to-end.

Spec doc `docs/specs/cli-output-formats.md` is updated to document the
single unified shape with orthogonal status/pathStatus axes and the
orphan-hive special case.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/specs/cli-output-formats.md              |  33 +-
 .../Acquisition/InstallationInfo.cs           | 106 +++++--
 src/Aspire.Cli/Commands/InfoOptionAction.cs   |   2 +
 .../Commands/InstallationInfoOutput.cs        | 128 ++++----
 src/Aspire.Cli/JsonSourceGenerationContext.cs |   2 +-
 .../InstallationDiscoveryDiscoverAllTests.cs  |   2 +-
 .../Commands/InfoOptionTests.cs               | 289 +++++++++++++++++-
 7 files changed, 466 insertions(+), 96 deletions(-)

diff --git a/docs/specs/cli-output-formats.md b/docs/specs/cli-output-formats.md
index e5bad47a867..121517bb0fa 100644
--- a/docs/specs/cli-output-formats.md
+++ b/docs/specs/cli-output-formats.md
@@ -486,32 +486,44 @@ The JSON form includes secret values. Do not redirect it to logs or files unless
     {
       "id": "script",
       "kind": "script",
-      "channel": "stable",
       "path": "/home/user/.aspire/bin/aspire",
+      "canonicalPath": "/home/user/.aspire/bin/aspire",
+      "version": "13.2.0",
+      "channel": "stable",
+      "source": "script",
       "hive": "/home/user/.aspire/hives/stable",
-      "status": "active"
+      "pathStatus": "active",
+      "status": "ok"
     },
     {
       "id": "pr-17400",
       "kind": "orphan-hive",
       "channel": "pr-17400",
       "hive": "/home/user/.aspire/hives/pr-17400",
+      "pathStatus": "notOnPath",
       "status": "no install found",
       "statusReason": "No discovered install reports this hive's channel."
     },
     {
-      "id": "stable",
+      "id": "stable-2",
       "kind": "homebrew",
-      "channel": "stable",
       "path": "/opt/homebrew/Caskroom/aspire/13.2.0/aspire",
-      "status": "active",
+      "canonicalPath": "/opt/homebrew/Caskroom/aspire/13.2.0/aspire",
+      "version": "13.2.0",
+      "channel": "stable",
+      "source": "brew",
+      "pathStatus": "shadowed",
+      "status": "ok",
       "managedBy": "homebrew"
     },
     {
       "id": "pr-17500",
       "kind": "pr",
-      "channel": "pr-17500",
       "path": "/home/user/.aspire/dogfood/pr-17500/bin/aspire",
+      "canonicalPath": "/home/user/.aspire/dogfood/pr-17500/bin/aspire",
+      "channel": "pr-17500",
+      "source": "pr",
+      "pathStatus": "notOnPath",
       "status": "failed",
       "statusReason": "Peer probe exited with code 137 (SIGKILL)."
     }
@@ -519,11 +531,16 @@ The JSON form includes secret values. Do not redirect it to logs or files unless
 }
 ```
 
-`installs[*].status` uses the install-discovery status (`active`, `shadowed`, `notOnPath`, `failed`, `notProbed`) or `no install found` for orphan hives. When the row has a human-readable reason (failed probes, orphan hives), it rides on the separate `statusReason` field — the `status` value itself stays enum-shaped so programmatic consumers can `switch` on it.
+Each entry in `installs[*]` is an `InstallationInfo` row — the same record shape used by `aspire --info --self --format json` (described below). The two status axes are orthogonal:
+
+- `status` is the lifecycle: `ok` (usable), `failed` (probe attempted but did not return usable data), `notProbed` (listed but not executed because required install metadata was missing or invalid), or `no install found` (orphan-hive directories with no matching binary).
+- `pathStatus` is the PATH-axis: `active` (first `aspire` resolved from `$PATH`), `shadowed` (on `$PATH` but masked by an earlier entry), or `notOnPath` (not discovered via `$PATH`).
+
+Programmatic consumers should `switch` on each axis independently. The `statusReason` field carries a human-readable explanation for non-`ok` rows; the `status` value itself stays enum-shaped. Nullable fields are omitted from JSON when absent (e.g., orphan-hive rows omit `path`, `canonicalPath`, `version`, `source`, `managedBy`).
 
 The top-level `channel` is the running CLI's identity (`local`, `stable`, `staging`, `daily`, or `pr-<N>`). It is omitted from the JSON output when the running binary has missing or invalid `AspireCliChannel` assembly metadata; the command still exits 0 so users can use `aspire --info` to diagnose a broken binary. The `installs` array is always present, possibly empty.
 
-`aspire --info --self --format json` is a hidden modifier used by the install-discovery peer-probe path so a newer CLI can ask a peer CLI to describe itself. Its output is a single-element array whose row carries the running CLI's own install metadata — `path`, `canonicalPath`, `version`, `channel`, `source`, `pathStatus`, `status`, and `statusReason`. That row shape is *distinct from* the `installs[*]` rows above: it has neither the `id`/`kind`/`hive`/`managedBy` aggregate-table fields nor the per-row sort projection. It is the internal cross-version contract between Aspire CLI builds and is not a stable surface for external tooling; it may change without notice.
+`aspire --info --self --format json` is a hidden modifier used by the install-discovery peer-probe path so a newer CLI can ask a peer CLI to describe itself. Its output is a single-element bare array whose element is an `InstallationInfo` row — the same record shape as `installs[*]` above. The `--self` row populates per-binary fields (`path`, `canonicalPath`, `version`, `channel`, `source`, `pathStatus`, `status`) for the running binary; the aggregate-only fields (`id`, `kind`, `hive`, `managedBy`) are omitted from a `--self` response because they are properties of the enumeration, not of the binary. This is the internal cross-version contract between Aspire CLI builds and is not a stable surface for external tooling; it may change without notice.
 
 ### `aspire config info`
 
diff --git a/src/Aspire.Cli/Acquisition/InstallationInfo.cs b/src/Aspire.Cli/Acquisition/InstallationInfo.cs
index cce0d98c3ee..fdd48fe823a 100644
--- a/src/Aspire.Cli/Acquisition/InstallationInfo.cs
+++ b/src/Aspire.Cli/Acquisition/InstallationInfo.cs
@@ -7,36 +7,75 @@
 namespace Aspire.Cli.Acquisition;
 
 /// <summary>
-/// Describes one Aspire CLI installation, as surfaced by
-/// <c>aspire --info --format json</c>. Each entry corresponds to a single
-/// binary either running this process or discovered on the system.
+/// Describes one row in the Aspire CLI install table, as surfaced by
+/// <c>aspire --info --format json</c> and <c>aspire --info --self --format json</c>.
 /// </summary>
 /// <remarks>
 /// <para>
-/// The JSON shape is part of the <c>aspire --info --self --format json</c> and
-/// <c>aspire --info --format json</c> contracts. Fields use camelCase wire names via
-/// <see cref="JsonPropertyNameAttribute"/> applied explicitly here so the
-/// schema stays decoupled from the project-wide camelCase policy: another
-/// process may parse this output across CLI versions and we don't want to
-/// rename fields by changing a global option.
+/// The same record shape is used by both surfaces:
 /// </para>
+/// <list type="bullet">
+///   <item><c>aspire --info --format json</c> emits an <c>InfoOutput</c>
+///     whose <c>installs</c> array contains <see cref="InstallationInfo"/>
+///     rows that may include both real CLI installs and orphan-hive rows.</item>
+///   <item><c>aspire --info --self --format json</c> emits a bare array with exactly
+///     one element describing the running binary.</item>
+/// </list>
 /// <para>
-/// Nullable fields may be <see langword="null"/> for any row, including
-/// rows with <see cref="InstallationInfoStatus.Ok"/>. For example, a legacy
-/// peer may respond through the <c>--version</c> fallback and leave
-/// <see cref="Channel"/> unknown. Consumers should treat null fields as
-/// "unknown for this row" regardless of <see cref="Status"/>.
+/// Fields use camelCase wire names via <see cref="JsonPropertyNameAttribute"/>
+/// applied explicitly here so the schema stays decoupled from the project-wide
+/// camelCase policy: another process may parse this output across CLI versions
+/// and we don't want to rename fields by changing a global option.
+/// </para>
+/// <para>
+/// The two status axes — <see cref="Status"/> (lifecycle) and
+/// <see cref="PathStatus"/> (PATH-axis) — are always orthogonal on the wire.
+/// Human renderings may collapse them; programmatic consumers should switch
+/// on each axis independently.
+/// </para>
+/// <para>
+/// Nullable fields may be <see langword="null"/> for any row, including rows
+/// with <see cref="InstallationInfoStatus.Ok"/>. For example, a peer probed via
+/// the <c>--version</c> fallback may leave <see cref="Channel"/> unknown.
+/// Consumers should treat null fields as "unknown for this row" regardless of
+/// <see cref="Status"/>. Orphan-hive rows (<see cref="Kind"/> equals
+/// <c>"orphan-hive"</c>) have a <see langword="null"/> <see cref="Path"/> by
+/// design — they represent a hive directory on disk with no matching CLI binary.
 /// </para>
 /// </remarks>
 internal sealed record InstallationInfo
 {
+    /// <summary>
+    /// Stable identifier for this row within an aggregate <c>aspire --info</c>
+    /// payload. Typically the channel (<c>stable</c>, <c>pr-17461</c>, ...) or
+    /// the install source (<c>script</c>) for ordinary installs, and the hive
+    /// directory name for orphan-hive rows. Duplicates are disambiguated by a
+    /// <c>-N</c> suffix. Not populated by the <c>--self</c> surface (a single
+    /// row needs no identifier).
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; init; }
+
+    /// <summary>
+    /// Row kind discriminator. For real installs this mirrors the install
+    /// source (<c>script</c>, <c>pr</c>, <c>winget</c>, <c>homebrew</c>,
+    /// <c>dotnet-tool</c>, <c>localhive</c>, ...). For hive directories on
+    /// disk that no discovered install claims, the kind is <c>orphan-hive</c>.
+    /// Not populated by the <c>--self</c> surface.
+    /// </summary>
+    [JsonPropertyName("kind")]
+    public string? Kind { get; init; }
+
     /// <summary>
     /// Absolute path of the CLI binary as discovered (i.e., the path that
     /// appeared in <c>$PATH</c> or a well-known location). May be a symlink;
     /// resolved canonical form is in <see cref="CanonicalPath"/>.
+    /// <see langword="null"/> only for orphan-hive rows
+    /// (<see cref="Kind"/> equals <c>"orphan-hive"</c>), which describe a hive
+    /// directory with no matching binary.
     /// </summary>
     [JsonPropertyName("path")]
-    public required string Path { get; init; }
+    public string? Path { get; init; }
 
     /// <summary>
     /// Symlink-resolved absolute path of the binary. Used for identity /
@@ -59,6 +98,7 @@ internal sealed record InstallationInfo
     /// <c>stable</c>, <c>staging</c>, <c>daily</c>, <c>local</c>, or
     /// <c>pr-&lt;N&gt;</c>. Always populated for the running row; for peer
     /// rows it is populated only when the peer was successfully probed.
+    /// Orphan-hive rows carry the hive's channel name here.
     /// </summary>
     [JsonPropertyName("channel")]
     public string? Channel { get; init; }
@@ -73,9 +113,20 @@ internal sealed record InstallationInfo
     [JsonPropertyName("source")]
     public string? Source { get; init; }
 
+    /// <summary>
+    /// Hive directory under <c>~/.aspire/hives/&lt;channel&gt;</c> when the
+    /// row corresponds to a hive on disk; <see langword="null"/> when the
+    /// install has no matching hive. For orphan-hive rows this is the hive
+    /// directory itself.
+    /// </summary>
+    [JsonPropertyName("hive")]
+    public string? Hive { get; init; }
+
     /// <summary>
     /// Relationship between this binary and the user's <c>$PATH</c>.
-    /// See <see cref="InstallationPathStatus"/>.
+    /// See <see cref="InstallationPathStatus"/>. Orthogonal to
+    /// <see cref="Status"/>. Defaults to <see cref="InstallationPathStatus.NotOnPath"/>
+    /// for orphan-hive rows.
     /// </summary>
     [JsonPropertyName("pathStatus")]
     public string PathStatus { get; init; } = InstallationPathStatus.NotOnPath;
@@ -86,8 +137,9 @@ internal sealed record InstallationInfo
     /// may still be absent. <c>notProbed</c> means the binary was listed but
     /// intentionally not executed because required install metadata was
     /// missing or invalid. <c>failed</c> means a probe was attempted but the
-    /// peer did not return usable data. Wire values are kept lowercase for
-    /// stability.
+    /// peer did not return usable data. <c>no install found</c> is reserved
+    /// for orphan-hive rows. Wire values are kept lowercase for stability.
+    /// Orthogonal to <see cref="PathStatus"/>.
     /// </summary>
     [JsonPropertyName("status")]
     public required string Status { get; init; }
@@ -98,6 +150,15 @@ internal sealed record InstallationInfo
     /// </summary>
     [JsonPropertyName("statusReason")]
     public string? StatusReason { get; init; }
+
+    /// <summary>
+    /// Package manager that owns this install, when applicable. Typically
+    /// <c>winget</c>, <c>homebrew</c>, or <c>dotnet-tool</c> — derived from
+    /// <see cref="Source"/>. <see langword="null"/> for installs not managed
+    /// by a recognised package manager.
+    /// </summary>
+    [JsonPropertyName("managedBy")]
+    public string? ManagedBy { get; init; }
 }
 
 /// <summary>
@@ -113,6 +174,9 @@ internal static class InstallationInfoStatus
 
     /// <summary>Probe was attempted, but the peer did not cooperate (timeout, non-zero exit, malformed JSON, etc.).</summary>
     public const string Failed = "failed";
+
+    /// <summary>Row describes an orphan hive directory on disk that no discovered install claims.</summary>
+    public const string NoInstallFound = "no install found";
 }
 
 /// <summary>
@@ -157,14 +221,18 @@ string GetStringOr(string property, string fallback)
 
         return new InstallationInfo
         {
-            Path = GetStringOr("path", string.Empty),
+            Id = GetOptionalString("id"),
+            Kind = GetOptionalString("kind"),
+            Path = GetOptionalString("path"),
             CanonicalPath = GetOptionalString("canonicalPath"),
             Version = GetOptionalString("version"),
             Channel = GetOptionalString("channel"),
             Source = GetOptionalString("source"),
+            Hive = GetOptionalString("hive"),
             PathStatus = pathStatus,
             Status = GetStringOr("status", InstallationInfoStatus.Ok),
             StatusReason = GetOptionalString("statusReason"),
+            ManagedBy = GetOptionalString("managedBy"),
         };
     }
 }
diff --git a/src/Aspire.Cli/Commands/InfoOptionAction.cs b/src/Aspire.Cli/Commands/InfoOptionAction.cs
index fa33f0f6ed0..cf78eef6736 100644
--- a/src/Aspire.Cli/Commands/InfoOptionAction.cs
+++ b/src/Aspire.Cli/Commands/InfoOptionAction.cs
@@ -155,8 +155,10 @@ private async Task<int> WriteFullInfoAsync(InfoOutputFormat format, Cancellation
             _interactionService.DisplayMarkdown($"**{row.Id}**  {row.Kind}");
             DisplayField("Status", row.Status);
             DisplayField("Channel", row.Channel);
+            DisplayField("Version", row.Version);
             DisplayField("Path", row.Path);
             DisplayField("Hive", row.Hive);
+            DisplayField("On PATH", row.PathStatus);
             if (row.StatusReason is { Length: > 0 })
             {
                 DisplayField("Reason", row.StatusReason);
diff --git a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
index 51fa35d72a4..9bfcd64385d 100644
--- a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
+++ b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
@@ -14,7 +14,7 @@ namespace Aspire.Cli.Commands;
 ///   <item><see cref="DescribeSelfSafely"/> — wraps <see cref="IInstallationDiscovery.DescribeSelf"/>
 ///   with the failure-tolerant shape consumed by the peer-probe contract.</item>
 ///   <item><see cref="BuildRowsAsync"/> and friends — classify a discovery walk into
-///   the <see cref="InstallListItem"/> rows surfaced by <c>aspire --info</c>.</item>
+///   the <see cref="InstallationInfo"/> rows surfaced by <c>aspire --info</c>.</item>
 /// </list>
 /// </summary>
 /// <remarks>
@@ -27,15 +27,6 @@ namespace Aspire.Cli.Commands;
 /// </remarks>
 internal static class InstallationInfoOutput
 {
-    /// <summary>
-    /// Wire value for the <c>status</c> field of a hive-only row that has no
-    /// matching discovered install. Single source of truth for both the row
-    /// constructor in <see cref="BuildRowsAsync"/> and the sort-key switch in
-    /// <see cref="GetSortRank"/> so a future rename can't silently split the
-    /// two and demote orphan rows out of their last-sorted bucket.
-    /// </summary>
-    internal const string OrphanHiveStatus = "no install found";
-
     public static IReadOnlyList<InstallationInfo> DescribeSelfSafely(IInstallationDiscovery discovery, ILogger logger)
     {
         try
@@ -55,7 +46,7 @@ public static IReadOnlyList<InstallationInfo> DescribeSelfSafely(IInstallationDi
         }
     }
 
-    public static async Task<List<InstallListItem>> BuildRowsSafelyAsync(HiveEnumerator hiveEnumerator, IInstallationDiscovery installationDiscovery, ILogger logger, CancellationToken cancellationToken)
+    public static async Task<List<InstallationInfo>> BuildRowsSafelyAsync(HiveEnumerator hiveEnumerator, IInstallationDiscovery installationDiscovery, ILogger logger, CancellationToken cancellationToken)
     {
         try
         {
@@ -75,20 +66,20 @@ public static async Task<List<InstallListItem>> BuildRowsSafelyAsync(HiveEnumera
             logger.LogWarning(ex, "Install discovery walk failed for `aspire --info`.");
             return
             [
-                new InstallListItem(
-                    Id: "discovery",
-                    Kind: "discovery-failed",
-                    Channel: null,
-                    Path: null,
-                    Hive: null,
-                    Status: InstallationInfoStatus.Failed,
-                    StatusReason: ex.Message,
-                    ManagedBy: null)
+                new InstallationInfo
+                {
+                    Id = "discovery",
+                    Kind = "discovery-failed",
+                    Path = null,
+                    PathStatus = InstallationPathStatus.NotOnPath,
+                    Status = InstallationInfoStatus.Failed,
+                    StatusReason = ex.Message,
+                }
             ];
         }
     }
 
-    public static async Task<List<InstallListItem>> BuildRowsAsync(HiveEnumerator hiveEnumerator, IInstallationDiscovery installationDiscovery, ILogger logger, CancellationToken cancellationToken)
+    public static async Task<List<InstallationInfo>> BuildRowsAsync(HiveEnumerator hiveEnumerator, IInstallationDiscovery installationDiscovery, ILogger logger, CancellationToken cancellationToken)
     {
         var discoveredInstalls = (await installationDiscovery.DiscoverAllAsync(cancellationToken))
             .Where(i => IsDisplayableInstall(i, logger))
@@ -98,32 +89,40 @@ public static async Task<List<InstallListItem>> BuildRowsAsync(HiveEnumerator hi
             .Where(c => !string.IsNullOrEmpty(c))
             .ToHashSet(StringComparer.Ordinal);
         var ids = new Dictionary<string, int>(StringComparer.Ordinal);
-        var rows = new List<InstallListItem>();
+        var rows = new List<InstallationInfo>();
 
         foreach (var install in discoveredInstalls)
         {
             var baseId = GetInstallId(install);
             var id = GetUniqueId(baseId, ids, logger);
             var kind = GetInstallKind(install);
-            var status = GetInstallStatus(install);
             var hive = install.Channel is { Length: > 0 } && hiveEnumerator.HasHive(install.Channel)
                 ? hiveEnumerator.GetHivePath(install.Channel)
                 : null;
             var managedBy = GetManagedBy(install);
             logger.LogDebug(
-                "Classified install path '{Path}' as id '{Id}', kind '{Kind}', channel '{Channel}', status '{Status}', hive '{Hive}', managedBy '{ManagedBy}'. Source='{Source}', pathStatus='{PathStatus}', discoveryStatus='{DiscoveryStatus}', reason='{Reason}'.",
+                "Classified install path '{Path}' as id '{Id}', kind '{Kind}', channel '{Channel}', status '{Status}', pathStatus '{PathStatus}', hive '{Hive}', managedBy '{ManagedBy}'. Source='{Source}', reason='{Reason}'.",
                 install.Path,
                 id,
                 kind,
                 install.Channel ?? "(none)",
-                status,
+                install.Status,
+                install.PathStatus,
                 hive ?? "(none)",
                 managedBy ?? "(none)",
                 install.Source ?? "(none)",
-                install.PathStatus,
-                install.Status,
                 install.StatusReason ?? "(none)");
-            rows.Add(new InstallListItem(id, kind, install.Channel, install.Path, hive, status, install.StatusReason, managedBy));
+            // The aggregate row carries the same field set as InstallationInfo;
+            // we keep `Status` and `PathStatus` orthogonal so consumers can
+            // switch on each axis independently. Display-side collapsing
+            // happens in the text renderer (see InfoOptionAction.WriteFullInfoAsync).
+            rows.Add(install with
+            {
+                Id = id,
+                Kind = kind,
+                Hive = hive,
+                ManagedBy = managedBy,
+            });
         }
 
         foreach (var hive in hiveEnumerator.GetHives().Where(h => !installChannels.Contains(h.Name)))
@@ -134,7 +133,19 @@ public static async Task<List<InstallListItem>> BuildRowsAsync(HiveEnumerator hi
                 hive.Path,
                 id,
                 hive.Name);
-            rows.Add(new InstallListItem(id, "orphan-hive", hive.Name, null, hive.Path, OrphanHiveStatus, "No discovered install reports this hive's channel.", null));
+            // Orphan-hive rows have no installation binary, so `Path` and most
+            // per-binary fields are null. The hive directory itself is in `Hive`.
+            rows.Add(new InstallationInfo
+            {
+                Id = id,
+                Kind = "orphan-hive",
+                Path = null,
+                Channel = hive.Name,
+                Hive = hive.Path,
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.NoInstallFound,
+                StatusReason = "No discovered install reports this hive's channel.",
+            });
         }
 
         return rows
@@ -143,15 +154,30 @@ public static async Task<List<InstallListItem>> BuildRowsAsync(HiveEnumerator hi
             .ToList();
     }
 
-    private static int GetSortRank(InstallListItem row)
-        => row.Status switch
+    // Sort order: active installs first, then shadowed, then not-on-PATH ok,
+    // then failed / notProbed, then orphan-hives last. Status and PathStatus
+    // are orthogonal on the wire, so the rank function combines both axes.
+    private static int GetSortRank(InstallationInfo row)
+    {
+        if (row.Status is InstallationInfoStatus.NoInstallFound)
+        {
+            return 4;
+        }
+
+        if (row.Status is not InstallationInfoStatus.Ok)
+        {
+            // failed / notProbed / unknown
+            return 3;
+        }
+
+        return row.PathStatus switch
         {
             InstallationPathStatus.Active => 0,
             InstallationPathStatus.Shadowed => 1,
             InstallationPathStatus.NotOnPath => 2,
-            OrphanHiveStatus => 4,
-            _ => 3
+            _ => 3,
         };
+    }
 
     private static string GetInstallId(InstallationInfo install)
     {
@@ -165,7 +191,7 @@ private static string GetInstallId(InstallationInfo install)
             return install.Channel;
         }
 
-        return install.Source ?? install.Path;
+        return install.Source ?? install.Path ?? "unknown";
     }
 
     private static bool IsDisplayableInstall(InstallationInfo install, ILogger logger)
@@ -176,7 +202,7 @@ private static bool IsDisplayableInstall(InstallationInfo install, ILogger logge
             return true;
         }
 
-        var fileName = Path.GetFileName(install.CanonicalPath ?? install.Path);
+        var fileName = Path.GetFileName(install.CanonicalPath ?? install.Path ?? string.Empty);
         var isAspireBinary = fileName is "aspire" or "aspire.exe";
         if (!isAspireBinary)
         {
@@ -231,22 +257,6 @@ private static string GetInstallKind(InstallationInfo install)
             _ => null
         };
 
-    private static string GetInstallStatus(InstallationInfo install)
-    {
-        // Keep `status` enum-shaped so programmatic consumers can switch on it.
-        // For non-Ok rows the discovery status ("failed" / "notProbed") is
-        // surfaced here; the human-readable reason rides on the separate
-        // `statusReason` field (see `docs/specs/cli-output-formats.md`). For Ok
-        // rows the path-status axis is what users actually want to act on, so
-        // we project that into `status` instead of always emitting "ok".
-        if (install.Status != InstallationInfoStatus.Ok)
-        {
-            return install.Status;
-        }
-
-        return install.PathStatus;
-    }
-
     private static IReadOnlyList<InstallationInfo> CreateFailedDiscoveryRow()
     {
         return
@@ -263,20 +273,6 @@ private static IReadOnlyList<InstallationInfo> CreateFailedDiscoveryRow()
     }
 }
 
-/// <summary>
-/// One row in the <c>aspire --info</c> install table. Surfaced as JSON when
-/// <c>--format json</c> is set.
-/// </summary>
-internal sealed record InstallListItem(
-    [property: JsonPropertyName("id")] string Id,
-    [property: JsonPropertyName("kind")] string Kind,
-    [property: JsonPropertyName("channel")] string? Channel,
-    [property: JsonPropertyName("path")] string? Path,
-    [property: JsonPropertyName("hive")] string? Hive,
-    [property: JsonPropertyName("status")] string Status,
-    [property: JsonPropertyName("statusReason")] string? StatusReason,
-    [property: JsonPropertyName("managedBy")] string? ManagedBy);
-
 /// <summary>
 /// Combined object emitted by <c>aspire --info --format json</c>. The
 /// per-install rows are produced by <see cref="InstallationInfoOutput.BuildRowsAsync"/>.
@@ -284,7 +280,7 @@ internal sealed record InstallListItem(
 internal sealed record InfoOutput(
     [property: JsonPropertyName("version")] string? Version,
     [property: JsonPropertyName("channel")] string? Channel,
-    [property: JsonPropertyName("installs")] IReadOnlyList<InstallListItem> Installs);
+    [property: JsonPropertyName("installs")] IReadOnlyList<InstallationInfo> Installs);
 
 /// <summary>
 /// Output format for <c>aspire --info</c>. <c>List</c> is the default text
diff --git a/src/Aspire.Cli/JsonSourceGenerationContext.cs b/src/Aspire.Cli/JsonSourceGenerationContext.cs
index 4e34f05cc2b..86e873f3ee6 100644
--- a/src/Aspire.Cli/JsonSourceGenerationContext.cs
+++ b/src/Aspire.Cli/JsonSourceGenerationContext.cs
@@ -55,7 +55,7 @@ namespace Aspire.Cli;
 [JsonSerializable(typeof(List<CandidateAppHostDisplayInfo>))]
 [JsonSerializable(typeof(InstallationInfo))]
 [JsonSerializable(typeof(InstallationInfo[]))]
-[JsonSerializable(typeof(List<InstallListItem>))]
+[JsonSerializable(typeof(List<InstallationInfo>))]
 [JsonSerializable(typeof(InfoOutput))]
 [JsonSerializable(typeof(AppHostInfoCacheEntry))]
 [JsonSerializable(typeof(AppHostProjectInspectionOutput))]
diff --git a/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs b/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs
index f73d14ba541..9ba3d7f0550 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/InstallationDiscoveryDiscoverAllTests.cs
@@ -700,7 +700,7 @@ public async Task DiscoverAllAsync_UnreadableDotnetToolStore_DoesNotFailDiscover
             Assert.NotEmpty(results);
             Assert.Equal(InstallationInfoStatus.Ok, results[0].Status);
             Assert.DoesNotContain(results, info =>
-                info.Path.StartsWith(toolStore, StringComparison.Ordinal) ||
+                (info.Path?.StartsWith(toolStore, StringComparison.Ordinal) ?? false) ||
                 (info.CanonicalPath?.StartsWith(toolStore, StringComparison.Ordinal) ?? false));
         }
         finally
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index abd70496846..304b8729107 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -353,12 +353,17 @@ public async Task Info_Json_IncludesDiscoveredInstallsBrokenRowsAndOrphanHives()
                 Assert.Equal("script", row!["id"]!.GetValue<string>());
                 Assert.Equal("script", row["kind"]!.GetValue<string>());
                 Assert.Equal("stable", row["channel"]!.GetValue<string>());
-                Assert.Equal("active", row["status"]!.GetValue<string>());
+                // Status (lifecycle) and pathStatus (PATH-axis) are orthogonal on the wire.
+                // The aggregate previously projected pathStatus into status for OK rows;
+                // unifying the shape with --self drops that projection.
+                Assert.Equal("ok", row["status"]!.GetValue<string>());
+                Assert.Equal("active", row["pathStatus"]!.GetValue<string>());
             },
             row =>
             {
                 Assert.Equal("script-2", row!["id"]!.GetValue<string>());
                 Assert.Equal("failed", row["status"]!.GetValue<string>());
+                Assert.Equal("shadowed", row["pathStatus"]!.GetValue<string>());
                 Assert.Equal("peer probe failed", row["statusReason"]!.GetValue<string>());
             },
             row =>
@@ -366,6 +371,10 @@ public async Task Info_Json_IncludesDiscoveredInstallsBrokenRowsAndOrphanHives()
                 Assert.Equal("pr-17400", row!["id"]!.GetValue<string>());
                 Assert.Equal("orphan-hive", row["kind"]!.GetValue<string>());
                 Assert.Equal("no install found", row["status"]!.GetValue<string>());
+                // Orphan-hive rows have no installation binary: path is absent (omitted
+                // by WhenWritingNull), hive points at the directory on disk.
+                Assert.Null(row["path"]);
+                Assert.NotNull(row["hive"]);
             });
     }
 
@@ -773,6 +782,284 @@ public async Task Info_Self_Json_IsParseableByInstallationInfoParser_PeerProbeCo
         Assert.Equal(InstallationInfoStatus.Ok, parsed.Status);
     }
 
+    [Fact]
+    public async Task Info_UnifiedShape_AggregateRowAndSelfRowHaveSameKeys()
+    {
+        // Contract pin: `--info --format json` (installs[*]) and
+        // `--info --self --format json` (bare array element) are the SAME wire
+        // shape — InstallationInfo. A consumer parsing one can use the same
+        // parser for the other. This catches a future drift where someone
+        // introduces a per-surface record type and silently splits the wire
+        // contract again.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Version = "13.2.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+
+        var aggregateExitCode = await command.Parse("--info --format json").InvokeAsync().DefaultTimeout();
+        Assert.Equal(CliExitCodes.Success, aggregateExitCode);
+        var aggregateRow = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject()["installs"]!.AsArray()[0]!.AsObject();
+        var aggregateKeys = aggregateRow.Select(kvp => kvp.Key).OrderBy(k => k, StringComparer.Ordinal).ToArray();
+
+        outputWriter.Logs.Clear();
+
+        var selfExitCode = await command.Parse("--info --self --format json").InvokeAsync().DefaultTimeout();
+        Assert.Equal(CliExitCodes.Success, selfExitCode);
+        var selfRow = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsArray()[0]!.AsObject();
+        var selfKeys = selfRow.Select(kvp => kvp.Key).OrderBy(k => k, StringComparer.Ordinal).ToArray();
+
+        // The aggregate carries `id`/`kind`/`hive`/`managedBy` always (even if
+        // some are absent from a particular row via WhenWritingNull). The
+        // --self surface populates `path`/`canonicalPath`/`version`/`source`/
+        // `pathStatus`/`status` for the running binary. Both row shapes are
+        // drawn from the same record, so any key present on one MUST be a
+        // valid key on the other; the unified shape is the union of fields
+        // the record exposes.
+        var aggregateKeySet = aggregateKeys.ToHashSet(StringComparer.Ordinal);
+        var selfKeySet = selfKeys.ToHashSet(StringComparer.Ordinal);
+        var allowedKeys = new HashSet<string>(StringComparer.Ordinal)
+        {
+            "id", "kind", "path", "canonicalPath", "version", "channel",
+            "source", "hive", "pathStatus", "status", "statusReason", "managedBy",
+        };
+        Assert.Subset(allowedKeys, aggregateKeySet);
+        Assert.Subset(allowedKeys, selfKeySet);
+    }
+
+    [Fact]
+    public async Task Info_Json_StatusAndPathStatusAreOrthogonalForOkInstalls()
+    {
+        // Contract pin: the aggregate previously projected pathStatus
+        // ("active"/"shadowed"/"notOnPath") into the `status` field for OK rows,
+        // which forced JSON consumers to disambiguate two axes from one field
+        // (and made it impossible to distinguish "ok and not on PATH" from
+        // "failed and not probed"). The unified shape exposes both axes
+        // independently: `status` is lifecycle (ok/failed/notProbed/no install
+        // found), `pathStatus` is the PATH-axis. Catches accidental
+        // re-introduction of the projection.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var exitCode = await command.Parse("--info --format json").InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var row = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject()["installs"]!.AsArray()[0]!;
+        // An OK install that is not on PATH must report status="ok" and pathStatus="notOnPath"
+        // — never status="notOnPath".
+        Assert.Equal("ok", row["status"]!.GetValue<string>());
+        Assert.Equal("notOnPath", row["pathStatus"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public async Task Info_Json_OrphanHiveRow_HasNullPathAndPopulatedHive()
+    {
+        // Contract pin: an orphan-hive row describes a hive directory on disk
+        // with no matching CLI binary, so `path` is absent (omitted via
+        // WhenWritingNull). The `hive` field carries the directory; `kind`
+        // is the discriminator. Catches accidental regressions that would
+        // populate a synthetic path.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        Directory.CreateDirectory(Path.Combine(aspireHome, "hives", "pr-17400", "packages"));
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        // No discovered installs — the hive directory is truly orphan.
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var exitCode = await command.Parse("--info --format json").InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var installs = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject()["installs"]!.AsArray();
+        var orphan = Assert.Single(installs, row => row!["kind"]!.GetValue<string>() == "orphan-hive");
+        Assert.Null(orphan!["path"]);
+        Assert.NotNull(orphan["hive"]);
+        Assert.Equal("pr-17400", orphan["channel"]!.GetValue<string>());
+        Assert.Equal("no install found", orphan["status"]!.GetValue<string>());
+        Assert.Equal("notOnPath", orphan["pathStatus"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public async Task Info_Json_SortOrder_ActiveThenShadowedThenNotOnPathThenFailedThenOrphanHive()
+    {
+        // Behavior pin: deterministic row order regardless of discovery yield.
+        // Active installs first (the one a user invokes), then shadowed
+        // (visible but masked), then not-on-PATH-but-ok (probed and usable),
+        // then failed/notProbed (anomalies), then orphan-hives (purely
+        // disk-side, no install). Stable across versions so a scripted
+        // consumer iterating `installs[]` sees the same prioritisation.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        Directory.CreateDirectory(Path.Combine(aspireHome, "hives", "pr-17400", "packages"));
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            },
+            [
+                new InstallationInfo
+                {
+                    Path = Path.Combine(aspireHome, "shadowed", "aspire"),
+                    CanonicalPath = Path.Combine(aspireHome, "shadowed", "aspire"),
+                    Channel = "daily",
+                    Source = "script",
+                    PathStatus = InstallationPathStatus.Shadowed,
+                    Status = InstallationInfoStatus.Ok,
+                },
+                new InstallationInfo
+                {
+                    Path = Path.Combine(aspireHome, "offpath", "aspire"),
+                    CanonicalPath = Path.Combine(aspireHome, "offpath", "aspire"),
+                    Channel = "staging",
+                    Source = "script",
+                    PathStatus = InstallationPathStatus.NotOnPath,
+                    Status = InstallationInfoStatus.Ok,
+                },
+                new InstallationInfo
+                {
+                    Path = Path.Combine(aspireHome, "broken", "aspire"),
+                    CanonicalPath = Path.Combine(aspireHome, "broken", "aspire"),
+                    Channel = "local",
+                    Source = "script",
+                    PathStatus = InstallationPathStatus.NotOnPath,
+                    Status = InstallationInfoStatus.Failed,
+                    StatusReason = "peer probe failed",
+                },
+            ])));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var exitCode = await command.Parse("--info --format json").InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var installs = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject()["installs"]!.AsArray();
+        Assert.Collection(installs,
+            row =>
+            {
+                Assert.Equal("ok", row!["status"]!.GetValue<string>());
+                Assert.Equal("active", row["pathStatus"]!.GetValue<string>());
+            },
+            row =>
+            {
+                Assert.Equal("ok", row!["status"]!.GetValue<string>());
+                Assert.Equal("shadowed", row["pathStatus"]!.GetValue<string>());
+            },
+            row =>
+            {
+                Assert.Equal("ok", row!["status"]!.GetValue<string>());
+                Assert.Equal("notOnPath", row["pathStatus"]!.GetValue<string>());
+            },
+            row =>
+            {
+                Assert.Equal("failed", row!["status"]!.GetValue<string>());
+            },
+            row =>
+            {
+                Assert.Equal("orphan-hive", row!["kind"]!.GetValue<string>());
+                Assert.Equal("no install found", row["status"]!.GetValue<string>());
+            });
+    }
+
+    [Fact]
+    public async Task Info_TextRendering_DisplaysStatusAndOnPathSeparately()
+    {
+        // Behavior pin: the human text rendering surfaces both lifecycle and
+        // PATH axes independently (`Status   ok` / `On PATH  active`) rather
+        // than collapsing the two into a single ambiguous Status line. This
+        // mirrors what `--self` has always done; unification extends it to the
+        // aggregate. Catches a future regression where a renderer change drops
+        // one of the two lines.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Version = "13.2.0",
+                Channel = "stable",
+                Source = "script",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var exitCode = await command.Parse("--info").InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var output = string.Join(Environment.NewLine, outputWriter.Logs);
+        Assert.Contains("Status   ok", output);
+        Assert.Contains("On PATH  active", output);
+    }
+
     private sealed class ConstantChannelReader(string channel) : IIdentityChannelReader
     {
         public string ReadChannel() => channel;

From d1a2479edcd8262675dea8bd3fa0f52e59bc21d3 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 00:27:55 -0400
Subject: [PATCH 06/15] fix(cli): stop walking the Windows registry on every
 non-winget startup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`aspire run`, `aspire add`, every CLI command on Windows currently walks
both HKCU and HKLM `Uninstall` hives looking for the winget portable
manifest entry, on every single startup, for any install path that
didn't ship the `.aspire-install.json` sidecar (notably dev builds and
legacy pre-sidecar installs). The probe has a positive fast path —
sidecar exists, skip — but no negative-result cache. The old
`{"source":"winget"}` byte-array writer only fires when the registry
confirms a winget install, so non-winget Windows users re-walk the
registry forever. The factory comment in `Program.cs` claimed "the
worst case here is a no-op", which is true about side effects but
misleading about cost.

Rework the probe as a sidecar back-fill that always writes after one
registry read, either the positive `{"source":"winget"}` payload (when
the running binary IS a winget portable install) or a
`{"backfilled":true}` sentinel otherwise. The sentinel has no `source`
field, so `InstallSidecarReader.TryRead` parses it as Unknown and
downstream consumers see the row identically to a missing sidecar. The
existing `File.Exists` fast path at the top of `EnsureSidecar` then
short-circuits every subsequent startup — `HasWingetAspireUninstallEntry`
runs at most once per install location, ever.

Rename for clarity:

- `WingetFirstRunProbe` → `WingetSidecarBackfill`. "FirstRun" implied
  run-once-and-never-again; the reality is "every run until a sidecar
  exists". "Probe" implied read-only detection; the type writes.
- `WingetFirstRunProbe.Run(string)` → `WingetSidecarBackfill.EnsureSidecar(string)`.
  The new name matches the post-call invariant: a sidecar exists at the
  binary directory (real or backfilled sentinel) unless the write itself
  failed.
- `Program.TryRunWingetFirstRunProbe` → `Program.TryEnsureWingetSidecar`.
- Test files `WingetRegistryProbeTests` / `WingetStartupProbeTests` →
  `WingetSidecarBackfillTests` / `WingetSidecarBackfillStartupTests`.

Surprises worth calling out:

- One small behavior change for non-winget Windows installs: discovery
  used to mark these rows as `notProbed` (no sidecar = "we won't execute
  this binary"). Post-change the sidecar exists (sentinel form), so
  discovery promotes the row to `ok` and spawns the peer probe. The
  spawn target is the running binary itself — same binary that just
  wrote the sentinel — so self-vouching is logically consistent; the
  `notProbed` outcome was a side effect of the missing-sidecar gate,
  not a deliberate categorization. End user effect: the running CLI's
  row in `aspire --info` shows a real version instead of "not probed".
- A user who later installs via winget on top of a previously
  probed-negative location pays one row of `source: null` until they
  reinstall or delete the sentinel. `EnsureSidecar_DoesNotPromoteBackfilledSentinel_OnLaterWingetRun`
  pins this trade-off explicitly. In practice winget portable installs
  land in their own directory under `%LOCALAPPDATA%\Microsoft\WinGet\Packages\`,
  so the collision is rare.
- The startup-contract tests (`WingetSidecarBackfillStartupTests`) now
  clean up the sentinel written next to the test runner binary; without
  cleanup, the second test would skip via the existing-sidecar fast path
  and pollute the build output across runs.

Tests:

- `WingetSidecarBackfillTests`:
  - `EnsureSidecar_WritesWingetSidecar_WhenRegistryClaimsWinget` — positive path.
  - `EnsureSidecar_WritesBackfilledSentinel_WhenRegistryDoesNotClaimWinget` — sentinel content + asserts `source` field intentionally absent.
  - `EnsureSidecar_SkipsRegistryWalk_WhenSidecarExists` — counting fake registry reader, asserts `CallCount == 0` (the cost-reduction guarantee).
  - `EnsureSidecar_DoesNotOverwriteExistingSidecar` — idempotency.
  - `EnsureSidecar_DoesNotPromoteBackfilledSentinel_OnLaterWingetRun` — trade-off pinned.
  - `EnsureSidecar_ConcurrentInvocations_ProduceSingleValidSidecar` `[Theory]` — both positive and negative concurrent paths.
- `WingetSidecarBackfillStartupTests`: renamed + cleanup of negative-result sentinel.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/specs/install-sources.md                 |   2 +-
 .../Acquisition/IWindowsRegistryReader.cs     |   2 +-
 .../Acquisition/WingetFirstRunProbe.cs        | 107 ----------
 .../Acquisition/WingetSidecarBackfill.cs      | 157 +++++++++++++++
 src/Aspire.Cli/Program.cs                     |  48 ++---
 .../Acquisition/WingetRegistryProbeTests.cs   | 105 ----------
 .../WingetSidecarBackfillStartupTests.cs      | 187 ++++++++++++++++++
 .../Acquisition/WingetSidecarBackfillTests.cs | 180 +++++++++++++++++
 .../Acquisition/WingetStartupProbeTests.cs    | 128 ------------
 tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs |   4 +-
 10 files changed, 553 insertions(+), 367 deletions(-)
 delete mode 100644 src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs
 create mode 100644 src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
 delete mode 100644 tests/Aspire.Cli.Tests/Acquisition/WingetRegistryProbeTests.cs
 create mode 100644 tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
 create mode 100644 tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs
 delete mode 100644 tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs

diff --git a/docs/specs/install-sources.md b/docs/specs/install-sources.md
index c37d9d7c0b0..690327b7cd3 100644
--- a/docs/specs/install-sources.md
+++ b/docs/specs/install-sources.md
@@ -44,7 +44,7 @@ the default Aspire home (`ASPIRE_HOME` when set, otherwise `$HOME/.aspire`).
 | Source       | Archive shape                          | Sidecar writer                                                      |
 |-------------|----------------------------------------|---------------------------------------------------------------------|
 | Homebrew    | shared per-RID tarball                 | cask `postflight` block in `eng/homebrew/aspire.rb.template`        |
-| winget      | shared per-RID zip                     | CLI first-run probe (`WingetFirstRunProbe`) — uses the WinGet portable ARP registry entry to confirm the running binary was placed by winget, then stamps the sidecar |
+| winget      | shared per-RID zip                     | CLI sidecar back-fill (`WingetSidecarBackfill`) — uses the WinGet portable ARP registry entry to confirm the running binary was placed by winget, then stamps the sidecar |
 | script      | shared per-RID archive                 | `eng/scripts/get-aspire-cli.{sh,ps1}` (post-extraction)             |
 | PR script   | shared per-RID archive                 | `eng/scripts/get-aspire-cli-pr.{sh,ps1}` (post-extraction)          |
 | dotnet-tool | source-exclusive nupkg                  | payload-embedded (staged by `Aspire.Cli.csproj` `_PreparePreBuiltCliBinaryForPackTool`) |
diff --git a/src/Aspire.Cli/Acquisition/IWindowsRegistryReader.cs b/src/Aspire.Cli/Acquisition/IWindowsRegistryReader.cs
index a287433f76c..358c0d2fcb9 100644
--- a/src/Aspire.Cli/Acquisition/IWindowsRegistryReader.cs
+++ b/src/Aspire.Cli/Acquisition/IWindowsRegistryReader.cs
@@ -10,7 +10,7 @@ namespace Aspire.Cli.Acquisition;
 /// <summary>
 /// Probes Windows-specific facts that identify whether the currently running
 /// CLI binary was placed by a winget portable install. Used by
-/// <see cref="WingetFirstRunProbe"/>; abstracted for testability.
+/// <see cref="WingetSidecarBackfill"/>; abstracted for testability.
 /// </summary>
 internal interface IWindowsRegistryReader
 {
diff --git a/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs b/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs
deleted file mode 100644
index 3be324babc1..00000000000
--- a/src/Aspire.Cli/Acquisition/WingetFirstRunProbe.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Text;
-using Microsoft.Extensions.Logging;
-
-namespace Aspire.Cli.Acquisition;
-
-/// <summary>
-/// First-run self-stamp for winget-installed CLI binaries. Writes the
-/// install-source sidecar when the OS reports the running binary as a winget
-/// portable install. See <c>docs/specs/install-sources.md</c>.
-/// </summary>
-internal sealed class WingetFirstRunProbe
-{
-    private static readonly byte[] s_wingetSidecarContent = Encoding.UTF8.GetBytes("{\"source\":\"winget\"}");
-
-    private readonly IWindowsRegistryReader _registry;
-    private readonly ILogger<WingetFirstRunProbe> _logger;
-
-    public WingetFirstRunProbe(IWindowsRegistryReader registry, ILogger<WingetFirstRunProbe> logger)
-    {
-        ArgumentNullException.ThrowIfNull(registry);
-        ArgumentNullException.ThrowIfNull(logger);
-        _registry = registry;
-        _logger = logger;
-    }
-
-    /// <summary>
-    /// Writes <c>&lt;binaryDir&gt;/.aspire-install.json</c> when the running
-    /// process is a winget portable install AND no sidecar exists yet.
-    /// Idempotent: any second call is a no-op.
-    /// </summary>
-    public void Run(string binaryDir)
-    {
-        if (string.IsNullOrEmpty(binaryDir))
-        {
-            return;
-        }
-
-        var sidecarPath = Path.Combine(binaryDir, InstallSidecarReader.SidecarFileName);
-        if (File.Exists(sidecarPath))
-        {
-            return;
-        }
-
-        var processPath = Environment.ProcessPath;
-        if (string.IsNullOrEmpty(processPath))
-        {
-            return;
-        }
-
-        if (!_registry.HasWingetAspireUninstallEntry(processPath))
-        {
-            return;
-        }
-
-        TryWriteSidecarAtomically(binaryDir, sidecarPath);
-    }
-
-    private void TryWriteSidecarAtomically(string binaryDir, string sidecarPath)
-    {
-        var tempPath = Path.Combine(binaryDir, $"{InstallSidecarReader.SidecarFileName}.{Guid.NewGuid():N}.tmp");
-
-        try
-        {
-            File.WriteAllBytes(tempPath, s_wingetSidecarContent);
-        }
-        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
-        {
-            _logger.LogDebug(ex, "Winget first-run probe could not write temp sidecar at {Path}.", tempPath);
-            return;
-        }
-
-        try
-        {
-            File.Move(tempPath, sidecarPath, overwrite: false);
-            _logger.LogDebug("Winget first-run probe wrote sidecar at {Path}.", sidecarPath);
-        }
-        catch (Exception ex)
-        {
-            // Either a concurrent winner already stamped the same literal bytes
-            // (IOException from overwrite:false), a permission failure, or any
-            // other unexpected error. The probe is best-effort startup code, so
-            // swallow the failure and always clean up the temp file we just
-            // created so a partial install doesn't leave litter behind.
-            _logger.LogDebug(ex, "Winget first-run probe could not rename temp sidecar to {Path}.", sidecarPath);
-            TryDeleteTemp(tempPath);
-        }
-    }
-
-    private void TryDeleteTemp(string tempPath)
-    {
-        try
-        {
-            File.Delete(tempPath);
-        }
-        catch (IOException ex)
-        {
-            _logger.LogDebug(ex, "Winget first-run probe could not delete temp sidecar at {Path}.", tempPath);
-        }
-        catch (UnauthorizedAccessException ex)
-        {
-            _logger.LogDebug(ex, "Winget first-run probe could not delete temp sidecar at {Path}.", tempPath);
-        }
-    }
-}
diff --git a/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs b/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
new file mode 100644
index 00000000000..e513b29e3b2
--- /dev/null
+++ b/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
@@ -0,0 +1,157 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text;
+using Microsoft.Extensions.Logging;
+
+namespace Aspire.Cli.Acquisition;
+
+/// <summary>
+/// Back-fills the install-source sidecar (<c>.aspire-install.json</c>) next to
+/// the running CLI binary. The winget portable manifest has no post-install
+/// hook, so unlike the other install routes (which stamp the sidecar from the
+/// installer script), winget installs rely on the CLI itself to write the
+/// sidecar on a subsequent startup. See <c>docs/specs/install-sources.md</c>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Called from the <see cref="CliExecutionContext"/> DI factory on every CLI
+/// startup (see <c>Program.TryEnsureWingetSidecar</c>). Two write paths:
+/// </para>
+/// <list type="bullet">
+///   <item>
+///     <description>
+///     <c>{"source":"winget"}</c> when the Windows Uninstall registry hive
+///     reports the running binary as a winget portable install. Promotes the
+///     row to a recognized winget install in <c>aspire --info</c>.
+///     </description>
+///   </item>
+///   <item>
+///     <description>
+///     <c>{"backfilled":true}</c> when the running binary is on Windows but
+///     not a winget install. This sentinel has no <c>source</c> field, so
+///     <see cref="InstallSidecarReader"/> parses it as <see cref="InstallSource.Unknown"/>
+///     and downstream consumers see the row exactly as they would for a
+///     missing sidecar — except the next startup hits the <c>File.Exists</c>
+///     fast path at the top of <see cref="EnsureSidecar(string)"/> and skips
+///     the registry walk. Without this negative marker, every non-winget
+///     Windows startup paid two full Uninstall-hive enumerations forever.
+///     </description>
+///   </item>
+/// </list>
+/// <para>
+/// Idempotent and atomic: an existing sidecar (real or backfilled sentinel)
+/// is never overwritten, so a later upgrade to a real install route that
+/// stamps its own sidecar wins on first run and the backfill never touches it.
+/// Concurrent invocations race the temp+move; the loser cleans up its temp
+/// file. Failures are logged but never thrown — back-fill is best-effort
+/// startup hygiene, not a CLI prerequisite.
+/// </para>
+/// </remarks>
+internal sealed class WingetSidecarBackfill
+{
+    // Positive write: the running binary IS a winget portable install. Promotes
+    // the row to a recognized winget install in `aspire --info`.
+    private static readonly byte[] s_wingetSidecarContent = Encoding.UTF8.GetBytes("{\"source\":\"winget\"}");
+
+    // Negative-result sentinel: the running binary is NOT a winget portable
+    // install on this host. Wire-identical to "no sidecar" because
+    // InstallSidecarReader.TryRead reports Unknown / null source when the
+    // `source` field is absent. Its only job is to make the `File.Exists`
+    // fast path at the top of EnsureSidecar fire on subsequent startups, so we
+    // walk the HKCU + HKLM Uninstall hives at most once per install location.
+    private static readonly byte[] s_backfilledSentinelContent = Encoding.UTF8.GetBytes("{\"backfilled\":true}");
+
+    private readonly IWindowsRegistryReader _registry;
+    private readonly ILogger<WingetSidecarBackfill> _logger;
+
+    public WingetSidecarBackfill(IWindowsRegistryReader registry, ILogger<WingetSidecarBackfill> logger)
+    {
+        ArgumentNullException.ThrowIfNull(registry);
+        ArgumentNullException.ThrowIfNull(logger);
+        _registry = registry;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Ensures that <c>&lt;binaryDir&gt;/.aspire-install.json</c> exists. On a
+    /// winget portable install writes <c>{"source":"winget"}</c>; on any other
+    /// Windows install writes a <c>{"backfilled":true}</c> sentinel so this
+    /// method's registry walk runs at most once per install location.
+    /// Idempotent: an existing sidecar is never overwritten.
+    /// </summary>
+    public void EnsureSidecar(string binaryDir)
+    {
+        if (string.IsNullOrEmpty(binaryDir))
+        {
+            return;
+        }
+
+        var sidecarPath = Path.Combine(binaryDir, InstallSidecarReader.SidecarFileName);
+        if (File.Exists(sidecarPath))
+        {
+            return;
+        }
+
+        var processPath = Environment.ProcessPath;
+        if (string.IsNullOrEmpty(processPath))
+        {
+            return;
+        }
+
+        // Pick the payload up front so the atomic-write helper is content-agnostic
+        // and both positive and negative paths share the same temp+move semantics.
+        var content = _registry.HasWingetAspireUninstallEntry(processPath)
+            ? s_wingetSidecarContent
+            : s_backfilledSentinelContent;
+
+        TryWriteSidecarAtomically(binaryDir, sidecarPath, content);
+    }
+
+    private void TryWriteSidecarAtomically(string binaryDir, string sidecarPath, byte[] content)
+    {
+        var tempPath = Path.Combine(binaryDir, $"{InstallSidecarReader.SidecarFileName}.{Guid.NewGuid():N}.tmp");
+
+        try
+        {
+            File.WriteAllBytes(tempPath, content);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            _logger.LogDebug(ex, "Winget sidecar back-fill could not write temp sidecar at {Path}.", tempPath);
+            return;
+        }
+
+        try
+        {
+            File.Move(tempPath, sidecarPath, overwrite: false);
+            _logger.LogDebug("Winget sidecar back-fill wrote sidecar at {Path}.", sidecarPath);
+        }
+        catch (Exception ex)
+        {
+            // Either a concurrent winner already stamped the same literal bytes
+            // (IOException from overwrite:false), a permission failure, or any
+            // other unexpected error. Back-fill is best-effort startup code, so
+            // swallow the failure and always clean up the temp file we just
+            // created so a partial install doesn't leave litter behind.
+            _logger.LogDebug(ex, "Winget sidecar back-fill could not rename temp sidecar to {Path}.", sidecarPath);
+            TryDeleteTemp(tempPath);
+        }
+    }
+
+    private void TryDeleteTemp(string tempPath)
+    {
+        try
+        {
+            File.Delete(tempPath);
+        }
+        catch (IOException ex)
+        {
+            _logger.LogDebug(ex, "Winget sidecar back-fill could not delete temp sidecar at {Path}.", tempPath);
+        }
+        catch (UnauthorizedAccessException ex)
+        {
+            _logger.LogDebug(ex, "Winget sidecar back-fill could not delete temp sidecar at {Path}.", tempPath);
+        }
+    }
+}
diff --git a/src/Aspire.Cli/Program.cs b/src/Aspire.Cli/Program.cs
index 3f6851f6b67..5a9e4b70a01 100644
--- a/src/Aspire.Cli/Program.cs
+++ b/src/Aspire.Cli/Program.cs
@@ -346,7 +346,7 @@ internal static async Task<IHost> BuildApplicationAsync(string[] args, CliStartu
         {
             builder.Services.AddSingleton<IWindowsRegistryReader, NullWindowsRegistryReader>();
         }
-        builder.Services.AddSingleton<WingetFirstRunProbe>();
+        builder.Services.AddSingleton<WingetSidecarBackfill>();
         builder.Services.AddSingleton(sp =>
         {
             var channelReader = sp.GetRequiredService<IIdentityChannelReader>();
@@ -362,18 +362,19 @@ internal static async Task<IHost> BuildApplicationAsync(string[] args, CliStartu
             // resolution point moves. InfoOptionAction bypasses this entirely
             // by injecting IIdentityChannelReader and handling failure itself.
             var lazyChannel = new Lazy<string>(channelReader.ReadChannel, LazyThreadSafetyMode.ExecutionAndPublication);
-            // Self-heal the install-source sidecar before anything reads it.
-            // WingetFirstRunProbe is a one-shot writer (no-op on non-Windows or
-            // when the running binary isn't a winget portable install). Running
-            // it here, inside the CliExecutionContext factory, guarantees the
-            // sidecar is stamped before BuildCliExecutionContext below resolves
-            // the install-aware Aspire home, before BundleService computes its
-            // extract dir, and before `aspire --info --self` reads `Source`.
-            // Without this, the first invocation from a fresh winget install
-            // would fall back to the legacy user-profile home and miss the
-            // source row, even though the sidecar would appear on subsequent
-            // runs. The probe is idempotent, so the worst case here is a no-op.
-            TryRunWingetFirstRunProbe(sp);
+            // Back-fill the install-source sidecar before anything reads it.
+            // WingetSidecarBackfill writes {"source":"winget"} when the running
+            // binary is a winget portable install, and a {"backfilled":true}
+            // sentinel otherwise so the registry walk runs at most once per
+            // install location. Either write guarantees the sidecar is present
+            // before BuildCliExecutionContext below resolves the install-aware
+            // Aspire home, before BundleService computes its extract dir, and
+            // before `aspire --info --self` reads `Source`. Without this,
+            // the first invocation from a fresh winget install would fall back
+            // to the legacy user-profile home and miss the source row even
+            // though the sidecar would appear on subsequent runs. The back-fill
+            // is idempotent and skips the registry walk on every later startup.
+            TryEnsureWingetSidecar(sp);
             return BuildCliExecutionContext(startupContext.LoggingOptions.DebugMode, startupContext.LoggingOptions.LogsDirectory, startupContext.LoggingOptions.LogFilePath, lazyChannel);
         });
         builder.Services.AddSingleton(s => new ConsoleEnvironment(
@@ -645,12 +646,13 @@ private static CliExecutionContext BuildCliExecutionContextCore(bool debugMode,
     }
 
     /// <summary>
-    /// Invokes <see cref="WingetFirstRunProbe.Run(string)"/> for the running binary's
-    /// directory, swallowing any failure so a misbehaving probe can never block CLI startup.
-    /// Called from the <see cref="CliExecutionContext"/> DI factory so the sidecar is
-    /// stamped before any code reads it.
+    /// Invokes <see cref="WingetSidecarBackfill.EnsureSidecar(string)"/> for the
+    /// running binary's directory, swallowing any failure so a misbehaving
+    /// back-fill can never block CLI startup. Called from the
+    /// <see cref="CliExecutionContext"/> DI factory so the sidecar is present
+    /// before any code reads it.
     /// </summary>
-    internal static void TryRunWingetFirstRunProbe(IServiceProvider sp)
+    internal static void TryEnsureWingetSidecar(IServiceProvider sp)
     {
         try
         {
@@ -666,16 +668,16 @@ internal static void TryRunWingetFirstRunProbe(IServiceProvider sp)
                 return;
             }
 
-            sp.GetRequiredService<WingetFirstRunProbe>().Run(binaryDir);
+            sp.GetRequiredService<WingetSidecarBackfill>().EnsureSidecar(binaryDir);
         }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
-            // The probe is best-effort startup hygiene: a stamping failure must
+            // Back-fill is best-effort startup hygiene: a write failure must
             // never block the rest of the CLI from starting. Log and continue —
-            // the worst case is that an unstamped winget install surfaces as an
+            // the worst case is that an unstamped install surfaces as an
             // unknown source until the next invocation retries.
-            var logger = sp.GetService<ILogger<WingetFirstRunProbe>>();
-            logger?.LogWarning(ex, "Winget first-run install sidecar probe failed during CLI startup.");
+            var logger = sp.GetService<ILogger<WingetSidecarBackfill>>();
+            logger?.LogWarning(ex, "Winget install-source sidecar back-fill failed during CLI startup.");
         }
     }
 
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetRegistryProbeTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetRegistryProbeTests.cs
deleted file mode 100644
index 1960adcb42b..00000000000
--- a/tests/Aspire.Cli.Tests/Acquisition/WingetRegistryProbeTests.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Concurrent;
-using System.Text.Json;
-using Aspire.Cli.Acquisition;
-using Microsoft.Extensions.Logging.Abstractions;
-
-namespace Aspire.Cli.Tests.Acquisition;
-
-public class WingetRegistryProbeTests
-{
-    private const string SidecarFileName = ".aspire-install.json";
-
-    [Theory]
-    [InlineData(true, true)]
-    [InlineData(false, false)]
-    public void Run_WritesSidecarOnlyWhenRegistryClaimsAspire(bool registryClaim, bool expectSidecar)
-    {
-        using var workspace = new TestTempDirectory();
-        var probe = new WingetFirstRunProbe(new FakeWindowsRegistryReader(claim: registryClaim), NullLogger<WingetFirstRunProbe>.Instance);
-
-        probe.Run(workspace.Path);
-
-        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
-        Assert.Equal(expectSidecar, File.Exists(sidecarPath));
-
-        if (expectSidecar)
-        {
-            using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath));
-            Assert.Equal(JsonValueKind.Object, doc.RootElement.ValueKind);
-            Assert.Equal("winget", doc.RootElement.GetProperty("source").GetString());
-        }
-        else
-        {
-            Assert.Empty(Directory.GetFiles(workspace.Path));
-        }
-    }
-
-    [Fact]
-    public void Run_IsIdempotent_OnSecondRun()
-    {
-        using var workspace = new TestTempDirectory();
-        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
-        // Pre-seed with a distinctive payload no real producer would write.
-        // The probe's contract is "do not touch an existing sidecar"; if it
-        // ever rewrites unconditionally, this distinctive payload would be
-        // overwritten with the probe's canonical {"source":"winget"} content
-        // and the assertion below would fail — independent of any filesystem
-        // timestamp resolution.
-        const string preSeededContent = "{\"source\":\"winget-pre-seeded\"}";
-        File.WriteAllText(sidecarPath, preSeededContent);
-
-        // Even with the registry asserting winget, an existing sidecar must
-        // not be touched.
-        var probe = new WingetFirstRunProbe(new FakeWindowsRegistryReader(claim: true), NullLogger<WingetFirstRunProbe>.Instance);
-        probe.Run(workspace.Path);
-
-        Assert.Equal(preSeededContent, File.ReadAllText(sidecarPath));
-    }
-
-    [Fact]
-    public async Task Run_ConcurrentInvocations_ProduceSingleValidSidecar()
-    {
-        using var workspace = new TestTempDirectory();
-        var probe = new WingetFirstRunProbe(new FakeWindowsRegistryReader(claim: true), NullLogger<WingetFirstRunProbe>.Instance);
-        var errors = new ConcurrentBag<Exception>();
-
-        var tasks = new Task[16];
-        for (var i = 0; i < tasks.Length; i++)
-        {
-            tasks[i] = Task.Run(() =>
-            {
-                try
-                {
-                    probe.Run(workspace.Path);
-                }
-                catch (Exception ex)
-                {
-                    errors.Add(ex);
-                }
-            });
-        }
-
-        await Task.WhenAll(tasks);
-
-        Assert.Empty(errors);
-
-        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
-        Assert.True(File.Exists(sidecarPath));
-
-        // Race losers must clean up their temp files.
-        var leftovers = Directory.GetFiles(workspace.Path, $"{SidecarFileName}.*.tmp");
-        Assert.Empty(leftovers);
-
-        using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath));
-        Assert.Equal(JsonValueKind.Object, doc.RootElement.ValueKind);
-        Assert.Equal("winget", doc.RootElement.GetProperty("source").GetString());
-    }
-}
-
-file sealed class FakeWindowsRegistryReader(bool claim) : IWindowsRegistryReader
-{
-    public bool HasWingetAspireUninstallEntry(string processPath) => claim;
-}
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
new file mode 100644
index 00000000000..6af2a20f356
--- /dev/null
+++ b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
@@ -0,0 +1,187 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Cli.Acquisition;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Aspire.Cli.Tests.Acquisition;
+
+/// <summary>
+/// Tests the startup-time invocation contract for <see cref="WingetSidecarBackfill"/>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The back-fill is fired exactly once from <see cref="Program.TryEnsureWingetSidecar(IServiceProvider)"/>,
+/// which is itself called from the <c>CliExecutionContext</c> DI singleton factory in
+/// <c>Program.BuildApplicationAsync</c>. The "factory invokes this helper" claim is a one-line
+/// code-review check at the factory body; the helper's own contract (resolves the back-fill, derives
+/// the binary directory from <see cref="Environment.ProcessPath"/>, swallows failures) is what is
+/// pinned here.
+/// </para>
+/// <para>
+/// The back-fill early-returns when the sidecar already exists at the target binary directory.
+/// In a normal test run the test host binary directory (the dotnet install root) carries no
+/// sidecar, but a stray sidecar would silently turn these tests into no-ops. Each test checks
+/// that precondition explicitly and skips with a diagnostic message otherwise.
+/// </para>
+/// </remarks>
+public class WingetSidecarBackfillStartupTests
+{
+    [Fact]
+    public void TryEnsureWingetSidecar_InvokesBackfillAgainstProcessBinaryDirectory()
+    {
+        var sidecarPath = AssertBackfillReachableFromTestRunner();
+
+        var registry = new CapturingWindowsRegistryReader();
+        using var provider = BuildMinimalProvider(registry);
+
+        try
+        {
+            Program.TryEnsureWingetSidecar(provider);
+
+            // The back-fill reached the registry-check arm exactly once, which means it
+            // resolved WingetSidecarBackfill from DI, derived the binary directory from
+            // Environment.ProcessPath, found no pre-existing sidecar, and queried our
+            // capturing reader for ARP membership. Returning false from the reader
+            // means the back-fill wrote the negative-result sentinel
+            // (`{"backfilled":true}`) near the test runner's binary; the finally block
+            // below deletes it so subsequent test runs aren't short-circuited by the
+            // existing-sidecar fast path.
+            Assert.Equal(1, registry.CallCount);
+            Assert.Equal(Environment.ProcessPath, registry.LastProcessPath);
+        }
+        finally
+        {
+            TryDeleteBackfilledSentinel(sidecarPath);
+        }
+    }
+
+    [Fact]
+    public void TryEnsureWingetSidecar_SwallowsRegistryReaderException()
+    {
+        var sidecarPath = AssertBackfillReachableFromTestRunner();
+
+        using var provider = BuildMinimalProvider(new ThrowingWindowsRegistryReader());
+
+        try
+        {
+            // No exception must escape: a registry probe failure during CLI startup
+            // is logged and treated as "not a winget install for this run", not a
+            // fatal error that prevents the CLI from launching.
+            var ex = Record.Exception(() => Program.TryEnsureWingetSidecar(provider));
+            Assert.Null(ex);
+        }
+        finally
+        {
+            // The throwing reader runs before any write attempt, so in normal
+            // execution no sentinel is written here — but a previous test
+            // failure or an interleaved run might have left one. Clean up
+            // defensively so the next test reaches the registry reader.
+            TryDeleteBackfilledSentinel(sidecarPath);
+        }
+    }
+
+    /// <summary>
+    /// Skips the test if <see cref="Environment.ProcessPath"/> is unavailable or
+    /// if a stray <c>.aspire-install.json</c> exists at the test host's binary
+    /// directory. Either condition would make the back-fill early-return before
+    /// reaching the registry reader, which would silently invalidate the assertion.
+    /// Returns the resolved sidecar path so the caller can clean it up after the run.
+    /// </summary>
+    private static string AssertBackfillReachableFromTestRunner()
+    {
+        var processPath = Environment.ProcessPath;
+        Assert.SkipUnless(
+            !string.IsNullOrEmpty(processPath),
+            "Environment.ProcessPath is unavailable in this test host; the startup back-fill cannot run.");
+
+        var binaryDir = Path.GetDirectoryName(processPath);
+        Assert.SkipUnless(
+            !string.IsNullOrEmpty(binaryDir),
+            $"Could not derive a binary directory from Environment.ProcessPath='{processPath}'.");
+
+        var sidecarPath = Path.Combine(binaryDir, InstallSidecarReader.SidecarFileName);
+        Assert.SkipUnless(
+            !File.Exists(sidecarPath),
+            $"Test host binary directory '{binaryDir}' already contains '{InstallSidecarReader.SidecarFileName}'; the back-fill would early-return before consulting the registry. " +
+            "Remove the stray sidecar or run the tests from a different host to exercise this scenario.");
+
+        return sidecarPath;
+    }
+
+    /// <summary>
+    /// Deletes the negative-result sentinel that <see cref="WingetSidecarBackfill.EnsureSidecar"/>
+    /// writes next to the test runner binary when <see cref="IWindowsRegistryReader.HasWingetAspireUninstallEntry"/>
+    /// returns <see langword="false"/>. Without this, the sentinel persists in the build
+    /// output and the back-fill's fast path short-circuits every subsequent run of these
+    /// tests. Failures are tolerated so test cleanup never masks the test's real failure.
+    /// </summary>
+    private static void TryDeleteBackfilledSentinel(string sidecarPath)
+    {
+        if (!File.Exists(sidecarPath))
+        {
+            return;
+        }
+
+        try
+        {
+            // Only delete what we wrote. A pre-existing sidecar (e.g. a real winget
+            // install) is filtered out by AssertBackfillReachableFromTestRunner's
+            // File.Exists skip, so anything we find here is a sentinel we wrote
+            // ourselves — but check the content anyway in case a parallel test
+            // wrote a different payload.
+            var content = File.ReadAllText(sidecarPath);
+            if (content.Contains("\"backfilled\":true", StringComparison.Ordinal))
+            {
+                File.Delete(sidecarPath);
+            }
+        }
+        catch (IOException)
+        {
+        }
+        catch (UnauthorizedAccessException)
+        {
+        }
+    }
+
+    private static ServiceProvider BuildMinimalProvider(IWindowsRegistryReader registry)
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton(registry);
+        // WingetSidecarBackfill's constructor takes ILogger<WingetSidecarBackfill>, so the
+        // registration must be against the interface — registering the concrete
+        // NullLogger<T> alone would leave DI unable to resolve the ctor parameter,
+        // and the outer try/catch in TryEnsureWingetSidecar would silently swallow
+        // the resolution failure instead of reaching the registry probe.
+        services.AddSingleton<ILogger<WingetSidecarBackfill>>(NullLogger<WingetSidecarBackfill>.Instance);
+        services.AddSingleton<WingetSidecarBackfill>();
+        return services.BuildServiceProvider();
+    }
+}
+
+/// <summary>
+/// Captures every <see cref="HasWingetAspireUninstallEntry"/> call and always
+/// returns <see langword="false"/> so the probe does not write a sidecar near
+/// the test host's binary.
+/// </summary>
+file sealed class CapturingWindowsRegistryReader : IWindowsRegistryReader
+{
+    private int _callCount;
+    public int CallCount => Volatile.Read(ref _callCount);
+    public string? LastProcessPath { get; private set; }
+
+    public bool HasWingetAspireUninstallEntry(string processPath)
+    {
+        Interlocked.Increment(ref _callCount);
+        LastProcessPath = processPath;
+        return false;
+    }
+}
+
+file sealed class ThrowingWindowsRegistryReader : IWindowsRegistryReader
+{
+    public bool HasWingetAspireUninstallEntry(string processPath)
+        => throw new InvalidOperationException("Simulated registry probe failure for test.");
+}
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs
new file mode 100644
index 00000000000..de877c12910
--- /dev/null
+++ b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs
@@ -0,0 +1,180 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Concurrent;
+using System.Text.Json;
+using Aspire.Cli.Acquisition;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace Aspire.Cli.Tests.Acquisition;
+
+public class WingetSidecarBackfillTests
+{
+    private const string SidecarFileName = ".aspire-install.json";
+
+    [Fact]
+    public void EnsureSidecar_WritesWingetSidecar_WhenRegistryClaimsWinget()
+    {
+        using var workspace = new TestTempDirectory();
+        var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: true), NullLogger<WingetSidecarBackfill>.Instance);
+
+        backfill.EnsureSidecar(workspace.Path);
+
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        Assert.True(File.Exists(sidecarPath));
+        using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath));
+        Assert.Equal(JsonValueKind.Object, doc.RootElement.ValueKind);
+        Assert.Equal("winget", doc.RootElement.GetProperty("source").GetString());
+    }
+
+    [Fact]
+    public void EnsureSidecar_WritesBackfilledSentinel_WhenRegistryDoesNotClaimWinget()
+    {
+        using var workspace = new TestTempDirectory();
+        var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: false), NullLogger<WingetSidecarBackfill>.Instance);
+
+        backfill.EnsureSidecar(workspace.Path);
+
+        // The sentinel is the cost-reduction half of the back-fill: writing it
+        // is what makes the next EnsureSidecar call short-circuit instead of
+        // walking HKCU and HKLM Uninstall hives again.
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        Assert.True(File.Exists(sidecarPath));
+        using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath));
+        Assert.Equal(JsonValueKind.Object, doc.RootElement.ValueKind);
+        Assert.True(doc.RootElement.GetProperty("backfilled").GetBoolean());
+        // Intentionally no "source" field — InstallSidecarReader treats the
+        // sentinel as Unknown source, wire-identical to a missing sidecar from
+        // downstream consumers' perspective.
+        Assert.False(doc.RootElement.TryGetProperty("source", out _));
+    }
+
+    [Fact]
+    public void EnsureSidecar_SkipsRegistryWalk_WhenSidecarExists()
+    {
+        // This is the central cost-reduction guarantee: once the sidecar exists
+        // (real or backfilled sentinel), EnsureSidecar must NOT consult the
+        // registry reader. The counting fake fails the test if it's invoked.
+        using var workspace = new TestTempDirectory();
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        File.WriteAllText(sidecarPath, "{\"backfilled\":true}");
+
+        var registry = new CountingFakeWindowsRegistryReader(claim: true);
+        var backfill = new WingetSidecarBackfill(registry, NullLogger<WingetSidecarBackfill>.Instance);
+
+        backfill.EnsureSidecar(workspace.Path);
+
+        Assert.Equal(0, registry.CallCount);
+    }
+
+    [Fact]
+    public void EnsureSidecar_DoesNotOverwriteExistingSidecar()
+    {
+        using var workspace = new TestTempDirectory();
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        // Pre-seed with a distinctive payload no real producer would write.
+        // The back-fill's contract is "do not touch an existing sidecar"; if it
+        // ever rewrites unconditionally, this distinctive payload would be
+        // overwritten with the canonical {"source":"winget"} content and the
+        // assertion below would fail — independent of any filesystem timestamp
+        // resolution.
+        const string preSeededContent = "{\"source\":\"winget-pre-seeded\"}";
+        File.WriteAllText(sidecarPath, preSeededContent);
+
+        // Even with the registry asserting winget, an existing sidecar must
+        // not be touched.
+        var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: true), NullLogger<WingetSidecarBackfill>.Instance);
+        backfill.EnsureSidecar(workspace.Path);
+
+        Assert.Equal(preSeededContent, File.ReadAllText(sidecarPath));
+    }
+
+    [Fact]
+    public void EnsureSidecar_DoesNotPromoteBackfilledSentinel_OnLaterWingetRun()
+    {
+        // Specific aspect of the "never overwrite" rule: a later run that
+        // would have written the positive payload still respects the sentinel
+        // from an earlier negative run. If a user really did install via winget
+        // after a prior probed-negative run, they pay one row of `source:null`
+        // in `aspire --info` until they reinstall or delete the sentinel — a
+        // bounded UX cost in exchange for not re-walking the registry every
+        // startup.
+        using var workspace = new TestTempDirectory();
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        const string sentinelContent = "{\"backfilled\":true}";
+        File.WriteAllText(sidecarPath, sentinelContent);
+
+        var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: true), NullLogger<WingetSidecarBackfill>.Instance);
+        backfill.EnsureSidecar(workspace.Path);
+
+        Assert.Equal(sentinelContent, File.ReadAllText(sidecarPath));
+    }
+
+    [Theory]
+    [InlineData(true, "winget")]
+    [InlineData(false, null)]
+    public async Task EnsureSidecar_ConcurrentInvocations_ProduceSingleValidSidecar(bool registryClaim, string? expectedSource)
+    {
+        using var workspace = new TestTempDirectory();
+        var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: registryClaim), NullLogger<WingetSidecarBackfill>.Instance);
+        var errors = new ConcurrentBag<Exception>();
+
+        var tasks = new Task[16];
+        for (var i = 0; i < tasks.Length; i++)
+        {
+            tasks[i] = Task.Run(() =>
+            {
+                try
+                {
+                    backfill.EnsureSidecar(workspace.Path);
+                }
+                catch (Exception ex)
+                {
+                    errors.Add(ex);
+                }
+            });
+        }
+
+        await Task.WhenAll(tasks);
+
+        Assert.Empty(errors);
+
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        Assert.True(File.Exists(sidecarPath));
+
+        // Race losers must clean up their temp files.
+        var leftovers = Directory.GetFiles(workspace.Path, $"{SidecarFileName}.*.tmp");
+        Assert.Empty(leftovers);
+
+        using var doc = JsonDocument.Parse(File.ReadAllBytes(sidecarPath));
+        Assert.Equal(JsonValueKind.Object, doc.RootElement.ValueKind);
+        if (expectedSource is null)
+        {
+            Assert.True(doc.RootElement.GetProperty("backfilled").GetBoolean());
+            Assert.False(doc.RootElement.TryGetProperty("source", out _));
+        }
+        else
+        {
+            Assert.Equal(expectedSource, doc.RootElement.GetProperty("source").GetString());
+        }
+    }
+}
+
+file sealed class FakeWindowsRegistryReader(bool claim) : IWindowsRegistryReader
+{
+    public bool HasWingetAspireUninstallEntry(string processPath) => claim;
+}
+
+// Counting variant used to assert that the fast path in EnsureSidecar skips
+// the registry walk entirely when a sidecar already exists.
+file sealed class CountingFakeWindowsRegistryReader(bool claim) : IWindowsRegistryReader
+{
+    private int _callCount;
+    public int CallCount => Volatile.Read(ref _callCount);
+
+    public bool HasWingetAspireUninstallEntry(string processPath)
+    {
+        Interlocked.Increment(ref _callCount);
+        return claim;
+    }
+}
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs
deleted file mode 100644
index d0f15468969..00000000000
--- a/tests/Aspire.Cli.Tests/Acquisition/WingetStartupProbeTests.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Aspire.Cli.Acquisition;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-
-namespace Aspire.Cli.Tests.Acquisition;
-
-/// <summary>
-/// Tests the startup-time invocation contract for <see cref="WingetFirstRunProbe"/>.
-/// </summary>
-/// <remarks>
-/// <para>
-/// The probe is fired exactly once from <see cref="Program.TryRunWingetFirstRunProbe(IServiceProvider)"/>,
-/// which is itself called from the <c>CliExecutionContext</c> DI singleton factory in
-/// <c>Program.BuildApplicationAsync</c>. The "factory invokes this helper" claim is a one-line
-/// code-review check at the factory body; the helper's own contract (resolves the probe, derives
-/// the binary directory from <see cref="Environment.ProcessPath"/>, swallows failures) is what is
-/// pinned here.
-/// </para>
-/// <para>
-/// The probe early-returns when the sidecar already exists at the target binary directory.
-/// In a normal test run the test host binary directory (the dotnet install root) carries no
-/// sidecar, but a stray sidecar would silently turn these tests into no-ops. Each test checks
-/// that precondition explicitly and skips with a diagnostic message otherwise.
-/// </para>
-/// </remarks>
-public class WingetStartupProbeTests
-{
-    [Fact]
-    public void TryRunWingetFirstRunProbe_InvokesProbeAgainstProcessBinaryDirectory()
-    {
-        AssertProbeReachableFromTestRunner();
-
-        var registry = new CapturingWindowsRegistryReader();
-        using var provider = BuildMinimalProvider(registry);
-
-        Program.TryRunWingetFirstRunProbe(provider);
-
-        // The probe reached the registry-check arm exactly once, which means it
-        // resolved WingetFirstRunProbe from DI, derived the binary directory from
-        // Environment.ProcessPath, found no pre-existing sidecar, and queried our
-        // capturing reader for ARP membership. Returning false from the reader
-        // also means no sidecar was written near the test runner's binary.
-        Assert.Equal(1, registry.CallCount);
-        Assert.Equal(Environment.ProcessPath, registry.LastProcessPath);
-    }
-
-    [Fact]
-    public void TryRunWingetFirstRunProbe_SwallowsRegistryReaderException()
-    {
-        AssertProbeReachableFromTestRunner();
-
-        using var provider = BuildMinimalProvider(new ThrowingWindowsRegistryReader());
-
-        // No exception must escape: a registry probe failure during CLI startup
-        // is logged and treated as "not a winget install for this run", not a
-        // fatal error that prevents the CLI from launching.
-        var ex = Record.Exception(() => Program.TryRunWingetFirstRunProbe(provider));
-        Assert.Null(ex);
-    }
-
-    /// <summary>
-    /// Skips the test if <see cref="Environment.ProcessPath"/> is unavailable or
-    /// if a stray <c>.aspire-install.json</c> exists at the test host's binary
-    /// directory. Either condition would make the probe early-return before
-    /// reaching the registry reader, which would silently invalidate the assertion.
-    /// </summary>
-    private static void AssertProbeReachableFromTestRunner()
-    {
-        var processPath = Environment.ProcessPath;
-        Assert.SkipUnless(
-            !string.IsNullOrEmpty(processPath),
-            "Environment.ProcessPath is unavailable in this test host; the startup probe cannot run.");
-
-        var binaryDir = Path.GetDirectoryName(processPath);
-        Assert.SkipUnless(
-            !string.IsNullOrEmpty(binaryDir),
-            $"Could not derive a binary directory from Environment.ProcessPath='{processPath}'.");
-
-        var sidecarPath = Path.Combine(binaryDir, ".aspire-install.json");
-        Assert.SkipUnless(
-            !File.Exists(sidecarPath),
-            $"Test host binary directory '{binaryDir}' already contains '{InstallSidecarReader.SidecarFileName}'; the probe would early-return before consulting the registry. " +
-            "Remove the stray sidecar or run the tests from a different host to exercise this scenario.");
-    }
-
-    private static ServiceProvider BuildMinimalProvider(IWindowsRegistryReader registry)
-    {
-        var services = new ServiceCollection();
-        services.AddSingleton(registry);
-        // WingetFirstRunProbe's constructor takes ILogger<WingetFirstRunProbe>, so the
-        // registration must be against the interface — registering the concrete
-        // NullLogger<T> alone would leave DI unable to resolve the ctor parameter,
-        // and the outer try/catch in TryRunWingetFirstRunProbe would silently swallow
-        // the resolution failure instead of reaching the registry probe.
-        services.AddSingleton<ILogger<WingetFirstRunProbe>>(NullLogger<WingetFirstRunProbe>.Instance);
-        services.AddSingleton<WingetFirstRunProbe>();
-        return services.BuildServiceProvider();
-    }
-}
-
-/// <summary>
-/// Captures every <see cref="HasWingetAspireUninstallEntry"/> call and always
-/// returns <see langword="false"/> so the probe does not write a sidecar near
-/// the test host's binary.
-/// </summary>
-file sealed class CapturingWindowsRegistryReader : IWindowsRegistryReader
-{
-    private int _callCount;
-    public int CallCount => Volatile.Read(ref _callCount);
-    public string? LastProcessPath { get; private set; }
-
-    public bool HasWingetAspireUninstallEntry(string processPath)
-    {
-        Interlocked.Increment(ref _callCount);
-        LastProcessPath = processPath;
-        return false;
-    }
-}
-
-file sealed class ThrowingWindowsRegistryReader : IWindowsRegistryReader
-{
-    public bool HasWingetAspireUninstallEntry(string processPath)
-        => throw new InvalidOperationException("Simulated registry probe failure for test.");
-}
diff --git a/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs b/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs
index 4d8e2fc0c12..f397e340b0f 100644
--- a/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs
+++ b/tests/Aspire.Cli.Tests/Utils/CliTestHelper.cs
@@ -169,9 +169,9 @@ public static IServiceCollection CreateServiceCollection(TemporaryWorkspace work
         services.AddSingleton<IInstallSidecarReader, InstallSidecarReader>();
         services.AddSingleton<IPeerInstallProbe, PeerInstallProbe>();
         services.AddSingleton<IInstallationDiscovery, InstallationDiscovery>();
-        services.AddSingleton<WingetFirstRunProbe>();
+        services.AddSingleton<WingetSidecarBackfill>();
         // Always register the null reader by default so unit tests don't reach into the
-        // actual user registry through WingetFirstRunProbe on Windows. Tests that need
+        // actual user registry through WingetSidecarBackfill on Windows. Tests that need
         // the real reader (or a fake) should replace the registration explicitly.
         services.AddSingleton<IWindowsRegistryReader, NullWindowsRegistryReader>();
         // IdentityChannelReader for AspireVersionCheck (doctor) — uses the same

From 84e412da20b70e77f8ce1d47909393e69f16984b Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 00:29:48 -0400
Subject: [PATCH 07/15] fix(cli): tolerate broken AspireCliChannel metadata in
 NewCommand/UpdateCommand ctors
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`aspire --info` is supposed to be the surface a user reaches for to
find out their binary is broken — including the case where the CLI
binary ships missing or invalid `[AssemblyMetadata("AspireCliChannel", ...)]`.
The `CliExecutionContext` DI factory in `Program.cs` already wraps
`IIdentityChannelReader.ReadChannel()` in a `Lazy<string>` precisely so
the context resolves cleanly when channel metadata is broken, and
`InfoOptionAction` injects the reader directly with its own try/catch.
Both pieces work in isolation. But the rest of the DI graph defeats
them: `NewCommand` and `UpdateCommand` are both pulled in as
constructor parameters of `RootCommand`, and both constructors read
`ExecutionContext.IdentityChannel` eagerly to pick a help-text variant
for `--channel`. On a broken-channel binary the Lazy throws on that
first access, `NewCommand`/`UpdateCommand` construction fails, and
`provider.GetRequiredService<RootCommand>()` throws — taking
`aspire --info` and `aspire --help` down with it.

Wrap the channel reads in tolerant helpers that mirror
`InfoOptionAction.TryReadChannel`: catch any non-cancellation
exception, fall back to the non-staging description, and let the
constructor complete. The fallback is benign — only the help text for
`--channel` loses its staging-channel mention; the option itself still
works, and the command's normal runtime reads of
`ExecutionContext.IdentityChannel` (which legitimately need to throw
on a broken binary) are unchanged.

Why the existing `Info_ChannelReadFailure_*` tests missed this:
`TestExecutionContextHelper.CreateExecutionContext` builds
`CliExecutionContext` with a literal `identityChannel: "local"` string
and leaves `IdentityChannelLazy` null, so
`CliExecutionContext.IdentityChannel` returns the literal string and
never invokes the throwing reader. Those tests exercise only the
direct-injection path inside `InfoOptionAction`, not the lazy property
path that production wiring goes through. Adding a sibling test that
sets `IdentityChannelLazy` to a throwing factory delegate exercises the
real production code path and pins both new tolerant helpers.

Tests:

- `InfoOptionTests.Info_ChannelLazyThrows_RootCommandStillResolves_AndInfoExitsZero`
  builds the service provider with a `CliExecutionContext` whose
  `IdentityChannelLazy.Value` throws on first access, resolves
  `RootCommand` (forcing every subcommand ctor through the throwing
  path), parses `--info --format json`, and asserts exit 0 with the
  channel field omitted from the JSON payload.
- Verified the test correctly fails under the pre-fix code by
  stashing the `NewCommand.cs` / `UpdateCommand.cs` changes and
  re-running — the resolution throws with
  `InvalidOperationException: AspireCliChannel assembly metadata is
  missing.` exactly as production would.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Aspire.Cli/Commands/NewCommand.cs         | 37 +++++++-
 src/Aspire.Cli/Commands/UpdateCommand.cs      | 23 ++++-
 .../Commands/InfoOptionTests.cs               | 86 +++++++++++++++++++
 3 files changed, 142 insertions(+), 4 deletions(-)

diff --git a/src/Aspire.Cli/Commands/NewCommand.cs b/src/Aspire.Cli/Commands/NewCommand.cs
index f7bbfeeb0cc..4bc4e88894c 100644
--- a/src/Aspire.Cli/Commands/NewCommand.cs
+++ b/src/Aspire.Cli/Commands/NewCommand.cs
@@ -101,9 +101,15 @@ public NewCommand(
         Options.Add(s_versionOption);
         Options.Add(s_suppressAgentInitOption);
 
-        // Customize description based on whether staging channel is enabled
+        // Customize description based on whether staging channel is enabled.
+        // Read ExecutionContext.IdentityChannel defensively: a binary with broken
+        // AspireCliChannel metadata throws here, and NewCommand is constructed as
+        // part of the RootCommand DI graph on every invocation — including the
+        // diagnostic surfaces (`aspire --info`, `aspire --help`) where we must
+        // not crash. Falling back to the non-staging description is acceptable
+        // because the option still works either way; only the help text differs.
         var isStagingEnabled = KnownFeatures.IsStagingChannelEnabled(_features, configuration)
-            || string.Equals(ExecutionContext.IdentityChannel, PackageChannelNames.Staging, StringComparisons.ChannelName);
+            || TryIsIdentityChannelStaging(executionContext);
         _channelOption = new Option<string?>("--channel")
         {
             Description = isStagingEnabled
@@ -481,6 +487,32 @@ private static bool ShouldResolveCliTemplateVersion(ITemplate template)
         return template.Runtime is TemplateRuntime.Cli;
     }
 
+    /// <summary>
+    /// Returns <see langword="true"/> when the running CLI's identity channel
+    /// is the staging channel. Wraps the <see cref="CliExecutionContext.IdentityChannel"/>
+    /// read in a tolerant try/catch so a binary with broken
+    /// <c>AspireCliChannel</c> assembly metadata does not crash
+    /// <see cref="NewCommand"/> construction — and through it the
+    /// <c>RootCommand</c> DI graph that <c>aspire --info</c> and
+    /// <c>aspire --help</c> resolve. Mirrors the posture of
+    /// <see cref="InfoOptionAction"/>'s channel-read helper. The fallback
+    /// (<see langword="false"/>) is benign: only the <c>--channel</c> option's
+    /// help text loses its staging-channel mention; the option itself still
+    /// works.
+    /// </summary>
+    private static bool TryIsIdentityChannelStaging(CliExecutionContext executionContext)
+    {
+        try
+        {
+            return string.Equals(executionContext.IdentityChannel, PackageChannelNames.Staging, StringComparisons.ChannelName);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            _ = ex;
+            return false;
+        }
+    }
+
 }
 
 internal interface INewCommandPrompter
@@ -639,6 +671,7 @@ public virtual async Task<ITemplate> PromptForTemplateAsync(ITemplate[] validTem
             cancellationToken: cancellationToken
         );
     }
+
 }
 
 internal static partial class ProjectNameValidator
diff --git a/src/Aspire.Cli/Commands/UpdateCommand.cs b/src/Aspire.Cli/Commands/UpdateCommand.cs
index 6103472f6c3..4b220e63bdd 100644
--- a/src/Aspire.Cli/Commands/UpdateCommand.cs
+++ b/src/Aspire.Cli/Commands/UpdateCommand.cs
@@ -461,8 +461,27 @@ protected override async Task<CommandResult> ExecuteAsync(ParseResult parseResul
 
     private bool IsStagingChannelAvailable()
     {
-        return KnownFeatures.IsStagingChannelEnabled(_features, _configuration)
-            || string.Equals(ExecutionContext.IdentityChannel, PackageChannelNames.Staging, StringComparisons.ChannelName);
+        if (KnownFeatures.IsStagingChannelEnabled(_features, _configuration))
+        {
+            return true;
+        }
+
+        // Read ExecutionContext.IdentityChannel defensively: a binary with broken
+        // AspireCliChannel metadata throws here, and UpdateCommand is constructed
+        // as part of the RootCommand DI graph on every invocation — including the
+        // diagnostic surfaces (`aspire --info`, `aspire --help`) where we must
+        // not crash. The runtime call site at the bottom of ExecuteSelfUpdateAsync
+        // also tolerates the false fallback: staging-channel offering is dropped
+        // from the channel prompt but the rest of update still works.
+        try
+        {
+            return string.Equals(ExecutionContext.IdentityChannel, PackageChannelNames.Staging, StringComparisons.ChannelName);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            _logger.LogDebug(ex, "Could not read identity channel for staging-channel detection; falling back to non-staging behavior.");
+            return false;
+        }
     }
 
     private async Task<CommandResult> ExecuteSelfUpdateAsync(ParseResult parseResult, CancellationToken cancellationToken, string? selectedChannel = null)
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index 304b8729107..c519b995f67 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -573,6 +573,92 @@ public async Task Info_ChannelReadFailure_Text_OmitsChannelLine()
         Assert.DoesNotContain("Channel  ", output);
     }
 
+    [Fact]
+    public async Task Info_ChannelLazyThrows_RootCommandStillResolves_AndInfoExitsZero()
+    {
+        // Production wiring: the CliExecutionContext DI factory in Program.cs wraps
+        // IIdentityChannelReader.ReadChannel() in a Lazy<string> on the context's
+        // IdentityChannelLazy property. The Lazy<>'s Value throws on first access
+        // when AspireCliChannel assembly metadata is missing or invalid. Any
+        // consumer that reads CliExecutionContext.IdentityChannel during DI graph
+        // construction therefore propagates the exception up the RootCommand
+        // resolution chain — which is the exact failure mode `aspire --info` must
+        // survive. NewCommand and UpdateCommand constructors both read the channel
+        // to pick a help-text variant; this test pins their tolerant fallback so
+        // a future refactor that re-introduces an eager read regresses the test.
+        // The sibling Info_ChannelReadFailure_* tests pin InfoOptionAction's own
+        // direct-injection read; together they cover both paths the production
+        // wiring exposes.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+            options.CliExecutionContextFactory = _ => CreateExecutionContextWithThrowingChannelLazy(workspace);
+        });
+        services.Replace(ServiceDescriptor.Singleton<IIdentityChannelReader>(_ => new ThrowingChannelReader()));
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = "/broken/aspire",
+                CanonicalPath = "/broken/aspire",
+                Version = "13.2.0",
+                Channel = null,
+                Source = "script",
+                PathStatus = InstallationPathStatus.NotOnPath,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        // The central assertion: resolving RootCommand pulls every subcommand
+        // into existence (NewCommand, UpdateCommand, ...). If any ctor reads
+        // CliExecutionContext.IdentityChannel without tolerating a throw, this
+        // line surfaces the bug — exactly as `aspire --info` would on a binary
+        // with broken AspireCliChannel metadata in production.
+        var command = provider.GetRequiredService<RootCommand>();
+
+        var result = command.Parse("--info --format json");
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        Assert.False(payload.ContainsKey("channel"));
+    }
+
+    private static CliExecutionContext CreateExecutionContextWithThrowingChannelLazy(TemporaryWorkspace workspace)
+    {
+        // Mirrors Program.BuildCliExecutionContext: the production factory sets
+        // IdentityChannelLazy to wrap IIdentityChannelReader.ReadChannel(), and
+        // CliExecutionContext.IdentityChannel forwards to lazy.Value when the
+        // lazy is non-null. A Lazy that throws inside its factory delegate
+        // throws the same exception on every Value access (ExecutionAndPublication
+        // caches the failure), which matches the production behavior of a
+        // binary with persistently broken channel metadata.
+        var root = workspace.WorkspaceRoot.FullName;
+        var hivesDirectory = new DirectoryInfo(Path.Combine(root, ".aspire", "hives"));
+        var homeDirectory = new DirectoryInfo(Path.Combine(root, ".home"));
+        var cacheDirectory = new DirectoryInfo(Path.Combine(root, ".aspire", "cache"));
+        var sdksDirectory = new DirectoryInfo(Path.Combine(root, ".aspire", "sdks"));
+        var logsDirectory = new DirectoryInfo(Path.Combine(root, ".aspire", "logs"));
+        var logFilePath = Path.Combine(logsDirectory.FullName, "test.log");
+
+        return new CliExecutionContext(
+            workspace.WorkspaceRoot,
+            hivesDirectory,
+            cacheDirectory,
+            sdksDirectory,
+            logsDirectory,
+            logFilePath,
+            debugMode: false,
+            homeDirectory: homeDirectory)
+        {
+            IdentityChannelLazy = new Lazy<string>(
+                () => throw new InvalidOperationException("AspireCliChannel assembly metadata is missing."),
+                LazyThreadSafetyMode.ExecutionAndPublication),
+        };
+    }
+
     [Fact]
     public async Task Info_LogsClassificationReasons()
     {

From abd887c2a1bacf7a6b6739155e9528c3ace4c3ff Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 00:30:41 -0400
Subject: [PATCH 08/15] fix(cli): IsInformationalInvocation misclassifies
 `--info` after root value-taking options and after `--`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`CommonOptionNames.IsInformationalInvocation` is the pre-parse gate
that decides whether an invocation is purely informational, so the CLI
can opt out of telemetry, suppress the first-run banner, and skip
consuming the one-shot first-run sentinel. It walks `args[]` once,
treating the first non-option token as the subcommand boundary; before
that boundary `--info` counts as informational, after it does not
(mirroring `--info`'s root-only / non-recursive binding on
RootCommand). Two correctness gaps in that scan:

1. **Value tokens for root value-taking options were being mistaken
   for subcommands.** Root options like `--log-level`, `-l`,
   `--format`, `--capture-profile-output`, `--capture-profile-delay`
   take a value in the next token, and value tokens don't start with
   `-`. The scan flipped `sawSubcommand=true` on the value, then
   refused to count the trailing `--info`. Real-world consequence:
   `aspire --log-level Debug --info`, `aspire --format json --info`
   (the exact example called out in the doc comment as "safe because
   the validator rejects it" — which is wrong, the validator only
   fires when --format is supplied WITHOUT --info), `aspire --locale
   fr-FR --info`, etc. all sent telemetry and showed the first-run
   banner — and on a fresh-install machine the banner could
   interleave with `--info --format json` output, breaking
   `PeerInstallProbe.TryParseRichProbeResult`'s JSON parse on the
   consumer side.

2. **The POSIX `--` end-of-options marker was ignored.** Tokens after
   `--` are positional / forwarded args (`aspire run -- --info`
   forwards `--info` to the AppHost), but the scan kept reading and
   would return true on the literal `--info` token. Result:
   `aspire -- --info` was misclassified as informational even though
   `--info` after `--` cannot bind to the root option in
   System.CommandLine.

The fix is the same shape as the original gate, with two added rules:

- Stop scanning at `arg == "--"`. The marker terminates option parsing
  by POSIX convention, so anything after — including `--info`,
  `--help`, `--version` — is a forwarded arg, not a CLI flag.
- Maintain a `s_rootOptionsTakingAValue` set listing the non-bool
  root options. When the scan sees one of these and we're still before
  any subcommand, skip the next token so the option's value isn't
  treated as a subcommand boundary. `=`-form (`--log-level=Debug`) is
  a single token that starts with `-` and needs no special handling.

The set is kept in sync by hand with the non-bool options declared on
RootCommand. A bool option (`--debug`, `--non-interactive`, ...)
doesn't take a separate value token and doesn't need to be listed.

Also corrected the outdated XML doc comment that claimed
`ValidateRequiresInfo` mitigates the `--format json --info` case — it
doesn't, because `--info` IS present in that invocation so the
validator passes.

Tests:

34 new test cases in `InfoOptionTests`, all named `IsInformationalInvocation_*`:

- `_ReturnsTrue_ForInfoAfterRootValueTakingOption` `[Theory]`, 9
  inlines — pins the value-skip across `--log-level`, `-l`, `--format`,
  `--capture-profile-output`, `--capture-profile-delay`, mixed, and
  `=`-form.
- `_ReturnsTrue_ForInfoAfterRootBoolOption` `[Theory]`, 6 inlines —
  sanity coverage for bool root options that don't need the skip, so a
  future accidental promotion into the value-taking set regresses one
  of these.
- `_ReturnsTrue_ForInfoBeforeSubcommandToken` — `["--info", "run"]`.
- `_ReturnsFalse_AfterEndOfOptionsMarker` `[Theory]`, 8 inlines —
  pins the `--` short-circuit across `aspire --`, `aspire run --`,
  `aspire run apphost.csproj --`, `aspire publish --` shapes, with
  every informational flag (`--info`, `--help`, `-h`, `--version`).
- `_ReturnsTrue_WhenInfoIsBeforeEndOfOptionsMarker` — `--info` before
  `--` still binds at root.
- `_ReturnsFalse_WhenInfoFollowsSubcommandEvenAfterRootValueTakingOption`
  `[Theory]`, 3 inlines — combined case from the bug-report shape.
- `_ReturnsFalse_ForEmptyArgs`, `_ReturnsFalse_ForNullArgs`,
  `_ReturnsFalse_ForBareSubcommand`,
  `_ReturnsFalse_ForValueTakingOptionAtEndOfArgsWithNoInfo` (`aspire
  --log-level`, malformed parse handled cleanly).
- `_ReturnsFalse_WhenValueLooksLikeInfo` — pathological `aspire
  --log-level --info` where `--info` is the VALUE of `--log-level`
  rather than a real flag.
- `_ReturnsTrue_ForVersionAtAnyPosition` — recursive-flag sanity.

Verified the new tests catch the bug: stashed
`src/Aspire.Cli/CommonOptionNames.cs` and re-ran the suite — 13 of
the 44 IsInformationalInvocation tests failed under the old code (7
for the value-taking-option case, 5 for the `--` case, 1 for the
pathological-value case). With the fix in place all 1301 Commands
tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Aspire.Cli/CommonOptionNames.cs           | 112 +++++++++++---
 .../Commands/InfoOptionTests.cs               | 143 ++++++++++++++++++
 2 files changed, 235 insertions(+), 20 deletions(-)

diff --git a/src/Aspire.Cli/CommonOptionNames.cs b/src/Aspire.Cli/CommonOptionNames.cs
index 081ee44318b..9a2275d9ffa 100644
--- a/src/Aspire.Cli/CommonOptionNames.cs
+++ b/src/Aspire.Cli/CommonOptionNames.cs
@@ -32,26 +32,46 @@ internal static class CommonOptionNames
     /// </summary>
     /// <remarks>
     /// <para>
-    /// <c>--version</c>, <c>--help</c>, <c>-h</c>, and <c>-?</c> are recursive in
-    /// System.CommandLine — they bind at any depth — so they really are informational at any
-    /// position (e.g. <c>aspire run --help</c> is genuinely a help invocation, not a
-    /// <c>run</c> invocation).
+    /// Three positional rules, in priority order:
     /// </para>
+    /// <list type="number">
+    ///   <item>
+    ///     <description>
+    ///     A POSIX <c>--</c> end-of-options marker terminates the scan. Tokens after
+    ///     <c>--</c> are positional / forwarded args (e.g. <c>aspire run -- --info</c>
+    ///     forwards <c>--info</c> to the AppHost) and never bind to a CLI option, so
+    ///     <c>--info</c> / <c>--help</c> / <c>--version</c> after <c>--</c> are not
+    ///     informational from the CLI's perspective.
+    ///     </description>
+    ///   </item>
+    ///   <item>
+    ///     <description>
+    ///     <c>--version</c>, <c>--help</c>, <c>-h</c>, and <c>-?</c> are recursive in
+    ///     System.CommandLine — they bind at any depth — so they really are
+    ///     informational at any position before <c>--</c> (e.g. <c>aspire run --help</c>
+    ///     is a help invocation, not a <c>run</c> invocation).
+    ///     </description>
+    ///   </item>
+    ///   <item>
+    ///     <description>
+    ///     <c>--info</c> is intentionally bound as a root-only non-recursive option on
+    ///     <c>RootCommand</c>. <c>aspire --info</c> fires the info action; <c>aspire run
+    ///     --info</c> runs the <c>run</c> subcommand with an unmatched <c>--info</c>
+    ///     token. The scan mirrors that binding: <c>--info</c> is treated as
+    ///     informational only when it appears <em>before</em> the first subcommand token
+    ///     (and before <c>--</c>).
+    ///     </description>
+    ///   </item>
+    /// </list>
     /// <para>
-    /// <c>--info</c>, by contrast, is intentionally wired as a root-only non-recursive option
-    /// on <c>RootCommand</c>. <c>aspire --info</c> fires the info action; <c>aspire run --info</c>
-    /// runs the <c>run</c> subcommand with an unmatched <c>--info</c> token. This helper mirrors
-    /// that binding: <c>--info</c> is treated as informational only when it appears before any
-    /// subcommand token in <paramref name="args"/>. Otherwise <c>aspire run --info</c> would
-    /// silently suppress telemetry and skip the first-run sentinel for a real <c>run</c>
-    /// invocation.
-    /// </para>
-    /// <para>
-    /// The first non-option token (one that does not start with <c>-</c>) is treated as the
-    /// subcommand boundary. A pathological case like <c>aspire --format json --info</c> — where
-    /// an option value happens to look like a subcommand — would short-circuit the <c>--info</c>
-    /// check; in practice the root-level <c>--format</c> validator rejects that parse anyway
-    /// when it's not paired with <c>--info</c>.
+    /// The "first non-option token = subcommand" heuristic has to handle one subtlety:
+    /// root-level options that <em>take a value</em> (<c>--log-level Debug</c>,
+    /// <c>--format json</c>, <c>--capture-profile-output path</c>, ...) put their value
+    /// in the next token, which doesn't start with <c>-</c>. Without special handling,
+    /// the scan would mistake the value for a subcommand and miss a trailing
+    /// <c>--info</c>. <see cref="s_rootOptionsTakingAValue"/> lists the affected option
+    /// names so the scan skips their value token. The <c>=</c>-form
+    /// (<c>--log-level=Debug</c>) is a single token and needs no special handling.
     /// </para>
     /// </remarks>
     public static bool IsInformationalInvocation(string[]? args)
@@ -62,24 +82,76 @@ public static bool IsInformationalInvocation(string[]? args)
         }
 
         var sawSubcommand = false;
+        var skipNext = false;
         foreach (var arg in args)
         {
+            if (skipNext)
+            {
+                // Previous token was a root value-taking option (e.g. --log-level);
+                // this token is its value, not a subcommand.
+                skipNext = false;
+                continue;
+            }
+
+            // POSIX end-of-options marker. Anything after this is forwarded /
+            // positional and cannot trigger a CLI informational action — including
+            // a literal `--info` or `--help` (rule 1).
+            if (arg == "--")
+            {
+                return false;
+            }
+
+            // Rule 3: --info is root-only / non-recursive, so it only counts as
+            // informational before any subcommand boundary.
             if (!sawSubcommand && arg == Info)
             {
                 return true;
             }
 
+            // Rule 2: --version / --help / -h / -? are recursive and remain
+            // informational at any position before --.
             if (arg is Version or Help or HelpShort or HelpAlt)
             {
                 return true;
             }
 
-            if (!sawSubcommand && arg.Length > 0 && arg[0] != '-')
+            if (arg.Length > 0 && arg[0] == '-')
             {
-                sawSubcommand = true;
+                // Root value-taking option in space-separated form: skip the
+                // value token so e.g. `aspire --log-level Debug --info` doesn't
+                // treat "Debug" as the subcommand boundary.
+                if (!sawSubcommand && s_rootOptionsTakingAValue.Contains(arg))
+                {
+                    skipNext = true;
+                }
+                continue;
             }
+
+            // First bare token (and not consumed as an option's value) is the
+            // subcommand. After this point, root-only `--info` no longer applies.
+            sawSubcommand = true;
         }
 
         return false;
     }
+
+    /// <summary>
+    /// Root-level options that take a value in space-separated form. Used by
+    /// <see cref="IsInformationalInvocation"/> to skip the value token so a value
+    /// that happens not to start with <c>-</c> (e.g. <c>Debug</c>, <c>json</c>) is
+    /// not mistaken for a subcommand boundary. Keep in sync with the non-bool
+    /// options declared on <see cref="Commands.RootCommand"/>: bool options
+    /// (<c>--debug</c>, <c>--non-interactive</c>, <c>--nologo</c>, <c>--banner</c>,
+    /// <c>--wait-for-debugger</c>, <c>--cli-wait-for-debugger</c>,
+    /// <c>--start-debug-session</c>, <c>--capture-profile</c>, <c>--info</c>,
+    /// <c>--self</c>) don't take a separate value token and don't appear here.
+    /// </summary>
+    private static readonly HashSet<string> s_rootOptionsTakingAValue = new(StringComparer.Ordinal)
+    {
+        "--log-level",
+        "-l",
+        "--format",
+        "--capture-profile-output",
+        "--capture-profile-delay",
+    };
 }
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index c519b995f67..bd078a5b24d 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -60,6 +60,149 @@ public void RecursiveInformationalFlags_OnSubcommand_RemainInformational(params
         Assert.True(CommonOptionNames.IsInformationalInvocation(args));
     }
 
+    [Theory]
+    // Each value-taking root option must skip its value token so the value
+    // doesn't get mistaken for a subcommand boundary. Without the skip, the
+    // gate misclassifies `aspire --log-level Debug --info` as a real `Debug`
+    // (subcommand) invocation and sends telemetry + shows the first-run banner
+    // for what is actually a diagnostic dump.
+    [InlineData("--log-level", "Debug", "--info")]
+    [InlineData("-l", "Debug", "--info")]
+    [InlineData("--format", "json", "--info")]
+    [InlineData("--format", "list", "--info")]
+    [InlineData("--capture-profile-output", "/tmp/profile.json", "--info")]
+    [InlineData("--capture-profile-delay", "10", "--info")]
+    // Mixed value-taking options before --info.
+    [InlineData("--log-level", "Debug", "--format", "json", "--info")]
+    // `=`-form values are a single token and don't need the skip. The token
+    // starts with `-` so the scan continues past it without flipping
+    // sawSubcommand; the next `--info` is still detected.
+    [InlineData("--log-level=Debug", "--info")]
+    [InlineData("--format=json", "--info")]
+    public void IsInformationalInvocation_ReturnsTrue_ForInfoAfterRootValueTakingOption(params string[] args)
+    {
+        Assert.True(CommonOptionNames.IsInformationalInvocation(args));
+    }
+
+    [Theory]
+    // Bool root options don't take a value token, so the scan just continues
+    // past them and finds the trailing --info. Sanity coverage so a future
+    // refactor that accidentally promotes a bool option into the
+    // value-taking set (or vice versa) regresses one of these.
+    [InlineData("--debug", "--info")]
+    [InlineData("-d", "--info")]
+    [InlineData("--non-interactive", "--info")]
+    [InlineData("--nologo", "--info")]
+    [InlineData("--banner", "--info")]
+    [InlineData("--debug", "--non-interactive", "--info")]
+    public void IsInformationalInvocation_ReturnsTrue_ForInfoAfterRootBoolOption(params string[] args)
+    {
+        Assert.True(CommonOptionNames.IsInformationalInvocation(args));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsTrue_ForInfoBeforeSubcommandToken()
+    {
+        // `aspire --info run` still binds --info at root (subcommand routing is
+        // skipped when a root option's action short-circuits, the same way
+        // `aspire --version run` works). The pre-parse gate must mirror that:
+        // --info before the first subcommand token is informational.
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["--info", "run"]));
+    }
+
+    [Theory]
+    // POSIX end-of-options marker: tokens after `--` are positional / forwarded
+    // and cannot trigger CLI actions. Forwarding examples:
+    //   aspire run -- --info     → AppHost receives --info as an arg
+    //   aspire run -- --help     → AppHost receives --help as an arg
+    // Plus the degenerate `aspire -- --info` where there is no subcommand to
+    // own the forwarded args — still not an informational invocation from the
+    // CLI's perspective.
+    [InlineData("--", "--info")]
+    [InlineData("--", "--help")]
+    [InlineData("--", "-h")]
+    [InlineData("--", "--version")]
+    [InlineData("run", "--", "--info")]
+    [InlineData("run", "--", "--help")]
+    [InlineData("run", "apphost.csproj", "--", "--info")]
+    [InlineData("publish", "--", "--info", "--format", "json")]
+    public void IsInformationalInvocation_ReturnsFalse_AfterEndOfOptionsMarker(params string[] args)
+    {
+        Assert.False(CommonOptionNames.IsInformationalInvocation(args));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsTrue_WhenInfoIsBeforeEndOfOptionsMarker()
+    {
+        // --info comes before `--`, so it still binds at root. The forwarded
+        // tokens that follow don't change the informational classification.
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["--info", "--", "forwarded-arg"]));
+    }
+
+    [Theory]
+    // After the subcommand boundary the value-skipping doesn't matter; --info
+    // is no longer informational regardless of what root options preceded it.
+    [InlineData("--log-level", "Debug", "run", "--info")]
+    [InlineData("--format", "json", "publish", "--info")]
+    [InlineData("--log-level=Debug", "run", "--info")]
+    public void IsInformationalInvocation_ReturnsFalse_WhenInfoFollowsSubcommandEvenAfterRootValueTakingOption(params string[] args)
+    {
+        Assert.False(CommonOptionNames.IsInformationalInvocation(args));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsFalse_ForEmptyArgs()
+    {
+        // No args means "no command" — System.CommandLine renders grouped help
+        // through a separate code path, and there's nothing here to opt out of
+        // telemetry / banner / sentinel for.
+        Assert.False(CommonOptionNames.IsInformationalInvocation([]));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsFalse_ForNullArgs()
+    {
+        Assert.False(CommonOptionNames.IsInformationalInvocation(null));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsFalse_ForValueTakingOptionAtEndOfArgsWithNoInfo()
+    {
+        // `aspire --log-level` is a malformed parse (missing value), but the
+        // gate must still return cleanly: the scan reads "--log-level", sets
+        // skipNext, the loop exits, and we return false because no --info /
+        // --help / --version ever appeared.
+        Assert.False(CommonOptionNames.IsInformationalInvocation(["--log-level"]));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsFalse_ForBareSubcommand()
+    {
+        Assert.False(CommonOptionNames.IsInformationalInvocation(["run"]));
+        Assert.False(CommonOptionNames.IsInformationalInvocation(["run", "apphost.csproj"]));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsFalse_WhenValueLooksLikeInfo()
+    {
+        // Pathological: a value-taking option whose value literally is the
+        // string "--info". `aspire --log-level --info` (where --info is the
+        // VALUE for --log-level, not a real option request) — the scan must
+        // not treat the value token as a root --info because skipNext is set.
+        // System.CommandLine would later reject this parse (--info isn't a
+        // valid LogLevel), but the gate has already correctly returned false.
+        Assert.False(CommonOptionNames.IsInformationalInvocation(["--log-level", "--info"]));
+    }
+
+    [Fact]
+    public void IsInformationalInvocation_ReturnsTrue_ForVersionAtAnyPosition()
+    {
+        // --version is recursive and informational at any depth (before --).
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["--version"]));
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["run", "--version"]));
+        Assert.True(CommonOptionNames.IsInformationalInvocation(["--log-level", "Debug", "--version"]));
+    }
+
     [Fact]
     public async Task Info_Self_Json_ReturnsOnlyRunningInstallationAsArray()
     {

From 4ccfb90462a1ad860cf2010141e9c4aecefe959d Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 00:59:02 -0400
Subject: [PATCH 09/15] fix(cli): stop writing winget-backfill sentinel on
 non-Windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

WingetSidecarBackfill.EnsureSidecar exists to amortize a HKCU + HKLM
Uninstall hive walk: on a winget portable install it stamps
{"source":"winget"}; on any other Windows install it writes a
{"backfilled":true} sentinel so the next startup hits the File.Exists
fast path and never re-walks the registry.

It was being invoked unconditionally from the CliExecutionContext DI
factory (Program.TryEnsureWingetSidecar). On Linux/macOS the
NullWindowsRegistryReader stub always returns false, so the helper
dropped the negative-result sentinel into the directory containing
Environment.ProcessPath — e.g. the dotnet global-tools store at
~/.dotnet/tools/.store/aspire.cli/<ver>/.../tools/<tfm>/<rid>/ — with
no amortization benefit, because there's no registry there to walk in
the first place. The write was harmless in isolation, but a stray
sidecar in the dotnet-tool layout silently re-classifies the install's
Source to a now-permanent sentinel-backed Unknown.

Gate EnsureSidecar with OperatingSystem.IsWindows() at the top, so the
method's contract (the docstring already says "on any other Windows
install ...") matches its observable behavior. The existing tests that
asserted the write happened unconditionally were also wrong on this
axis; gate them with Assert.SkipUnless(OperatingSystem.IsWindows())
mirroring WindowsRegistryReaderTests, and pin the new no-op behavior
with EnsureSidecar_IsNoOp_OnNonWindows.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Acquisition/WingetSidecarBackfill.cs      | 11 ++++++
 .../WingetSidecarBackfillStartupTests.cs      |  4 +++
 .../Acquisition/WingetSidecarBackfillTests.cs | 36 +++++++++++++++++++
 3 files changed, 51 insertions(+)

diff --git a/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs b/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
index e513b29e3b2..7bb81246eed 100644
--- a/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
+++ b/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
@@ -82,6 +82,17 @@ public WingetSidecarBackfill(IWindowsRegistryReader registry, ILogger<WingetSide
     /// </summary>
     public void EnsureSidecar(string binaryDir)
     {
+        // The back-fill exists solely to amortize a HKCU + HKLM Uninstall hive walk
+        // that only makes sense on Windows; on Linux/macOS there is no registry to
+        // probe and IWindowsRegistryReader resolves to a no-op stub. Writing a
+        // negative-result sentinel on non-Windows would still drop a stray
+        // .aspire-install.json next to the running binary (e.g. under the dotnet
+        // global-tools store) with no corresponding benefit, so exit before any IO.
+        if (!OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
         if (string.IsNullOrEmpty(binaryDir))
         {
             return;
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
index 6af2a20f356..c0858713cb9 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
@@ -32,6 +32,8 @@ public class WingetSidecarBackfillStartupTests
     [Fact]
     public void TryEnsureWingetSidecar_InvokesBackfillAgainstProcessBinaryDirectory()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is a Windows-only back-fill; off Windows it early-returns before resolving DI.");
+
         var sidecarPath = AssertBackfillReachableFromTestRunner();
 
         var registry = new CapturingWindowsRegistryReader();
@@ -61,6 +63,8 @@ public void TryEnsureWingetSidecar_InvokesBackfillAgainstProcessBinaryDirectory(
     [Fact]
     public void TryEnsureWingetSidecar_SwallowsRegistryReaderException()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is a Windows-only back-fill; off Windows it early-returns before consulting the registry reader, so a throwing reader is unreachable.");
+
         var sidecarPath = AssertBackfillReachableFromTestRunner();
 
         using var provider = BuildMinimalProvider(new ThrowingWindowsRegistryReader());
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs
index de877c12910..957c3de7230 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillTests.cs
@@ -15,6 +15,8 @@ public class WingetSidecarBackfillTests
     [Fact]
     public void EnsureSidecar_WritesWingetSidecar_WhenRegistryClaimsWinget()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is Windows-only.");
+
         using var workspace = new TestTempDirectory();
         var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: true), NullLogger<WingetSidecarBackfill>.Instance);
 
@@ -30,6 +32,8 @@ public void EnsureSidecar_WritesWingetSidecar_WhenRegistryClaimsWinget()
     [Fact]
     public void EnsureSidecar_WritesBackfilledSentinel_WhenRegistryDoesNotClaimWinget()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is Windows-only.");
+
         using var workspace = new TestTempDirectory();
         var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: false), NullLogger<WingetSidecarBackfill>.Instance);
 
@@ -52,6 +56,8 @@ public void EnsureSidecar_WritesBackfilledSentinel_WhenRegistryDoesNotClaimWinge
     [Fact]
     public void EnsureSidecar_SkipsRegistryWalk_WhenSidecarExists()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is Windows-only.");
+
         // This is the central cost-reduction guarantee: once the sidecar exists
         // (real or backfilled sentinel), EnsureSidecar must NOT consult the
         // registry reader. The counting fake fails the test if it's invoked.
@@ -70,6 +76,8 @@ public void EnsureSidecar_SkipsRegistryWalk_WhenSidecarExists()
     [Fact]
     public void EnsureSidecar_DoesNotOverwriteExistingSidecar()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is Windows-only.");
+
         using var workspace = new TestTempDirectory();
         var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
         // Pre-seed with a distinctive payload no real producer would write.
@@ -92,6 +100,8 @@ public void EnsureSidecar_DoesNotOverwriteExistingSidecar()
     [Fact]
     public void EnsureSidecar_DoesNotPromoteBackfilledSentinel_OnLaterWingetRun()
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is Windows-only.");
+
         // Specific aspect of the "never overwrite" rule: a later run that
         // would have written the positive payload still respects the sentinel
         // from an earlier negative run. If a user really did install via winget
@@ -115,6 +125,8 @@ public void EnsureSidecar_DoesNotPromoteBackfilledSentinel_OnLaterWingetRun()
     [InlineData(false, null)]
     public async Task EnsureSidecar_ConcurrentInvocations_ProduceSingleValidSidecar(bool registryClaim, string? expectedSource)
     {
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is Windows-only.");
+
         using var workspace = new TestTempDirectory();
         var backfill = new WingetSidecarBackfill(new FakeWindowsRegistryReader(claim: registryClaim), NullLogger<WingetSidecarBackfill>.Instance);
         var errors = new ConcurrentBag<Exception>();
@@ -158,6 +170,30 @@ public async Task EnsureSidecar_ConcurrentInvocations_ProduceSingleValidSidecar(
             Assert.Equal(expectedSource, doc.RootElement.GetProperty("source").GetString());
         }
     }
+
+    [Fact]
+    public void EnsureSidecar_IsNoOp_OnNonWindows()
+    {
+        Assert.SkipWhen(OperatingSystem.IsWindows(), "Test pins the non-Windows no-op contract; on Windows the back-fill writes a sentinel.");
+
+        // The amortization the back-fill exists for (HKCU + HKLM Uninstall hive walk)
+        // is meaningless off Windows, where IWindowsRegistryReader resolves to a
+        // no-op stub. Writing a sentinel anyway would litter the dotnet global-tools
+        // store and other Unix install layouts. The contract pinned here is the
+        // direct counterpart of the IsWindows guard in EnsureSidecar.
+        using var workspace = new TestTempDirectory();
+        var registry = new CountingFakeWindowsRegistryReader(claim: false);
+        var backfill = new WingetSidecarBackfill(registry, NullLogger<WingetSidecarBackfill>.Instance);
+
+        backfill.EnsureSidecar(workspace.Path);
+
+        // No sidecar written and no registry probe attempted: the early-return
+        // must precede both the IO and the registry call.
+        var sidecarPath = Path.Combine(workspace.Path, SidecarFileName);
+        Assert.False(File.Exists(sidecarPath));
+        Assert.Empty(Directory.GetFiles(workspace.Path));
+        Assert.Equal(0, registry.CallCount);
+    }
 }
 
 file sealed class FakeWindowsRegistryReader(bool claim) : IWindowsRegistryReader

From 4b9003efc5c0e65a07c6c635b8784f17e473dc21 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 00:59:12 -0400
Subject: [PATCH 10/15] fix(cli): make `aspire --info` accept non-lowercase
 Windows binary names
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

IsDisplayableInstall is the filter that decides whether a sidecar-less
discovery row gets surfaced in `aspire --info`. It used a case-sensitive
pattern match — `fileName is "aspire" or "aspire.exe"`.

PathLookupHelper deliberately preserves whatever spelling NTFS recorded
for the binary (that's the point of the recent on-disk-casing fix);
Windows command resolution is case-insensitive, so a real install with
on-disk filename `Aspire.exe` or `ASPIRE.EXE` and no sidecar would be
silently filtered out as "not an Aspire CLI binary" and never appear in
`aspire --info`.

Switch to string.Equals with OrdinalIgnoreCase on Windows and Ordinal
elsewhere, so POSIX paths stay case-sensitive (a deliberately-named
`Aspire` script on Linux is still excluded). Cover the three plausible
on-disk spellings with a Windows-only Theory in InfoOptionTests.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Commands/InstallationInfoOutput.cs        | 11 ++++-
 .../Commands/InfoOptionTests.cs               | 48 +++++++++++++++++++
 2 files changed, 58 insertions(+), 1 deletion(-)

diff --git a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
index 9bfcd64385d..5bcda1e7561 100644
--- a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
+++ b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
@@ -203,7 +203,16 @@ private static bool IsDisplayableInstall(InstallationInfo install, ILogger logge
         }
 
         var fileName = Path.GetFileName(install.CanonicalPath ?? install.Path ?? string.Empty);
-        var isAspireBinary = fileName is "aspire" or "aspire.exe";
+        // Windows command lookup is case-insensitive and PathLookupHelper preserves
+        // whatever spelling the filesystem records (e.g. `Aspire.exe`, `ASPIRE.EXE`).
+        // Using a case-sensitive match here would silently hide sidecar-less Windows
+        // installs whose on-disk filename is not lowercase. POSIX paths stay
+        // case-sensitive so a deliberately-named `Aspire` script on Linux is still
+        // excluded.
+        var comparison = OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+        var isAspireBinary =
+            string.Equals(fileName, "aspire", comparison) ||
+            string.Equals(fileName, "aspire.exe", comparison);
         if (!isAspireBinary)
         {
             logger.LogDebug("Ignoring discovery row path '{Path}' because it has no install source and the resolved filename '{FileName}' is not an Aspire CLI binary.", install.Path, fileName);
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index bd078a5b24d..53537904e88 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -600,6 +600,54 @@ public async Task Info_Json_EmptyInstalls_StillEmitsArray()
         Assert.Empty(installs);
     }
 
+    [Theory]
+    [InlineData("ASPIRE.EXE")]
+    [InlineData("Aspire.exe")]
+    [InlineData("aspire.EXE")]
+    public async Task Info_Json_IncludesSidecarLessWindowsInstall_WithNonLowercaseFilename(string fileName)
+    {
+        // PathLookupHelper preserves the filesystem's recorded casing on Windows,
+        // and Windows command lookup is case-insensitive — installs whose on-disk
+        // executable is e.g. `Aspire.exe` or `ASPIRE.EXE` are real and must not be
+        // filtered out as "not an Aspire binary" just because IsDisplayableInstall
+        // is comparing strings.
+        Assert.SkipUnless(OperatingSystem.IsWindows(), "Windows command lookup is the only path where case-insensitive filename matching applies.");
+
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        var installPath = $@"C:\Tools\Aspire\{fileName}";
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = installPath,
+                CanonicalPath = installPath,
+                Version = "13.2.0",
+                Channel = "10.0",
+                // Source = null — exercises the IsDisplayableInstall fallback that
+                // examines the resolved filename rather than the sidecar.
+                Source = null,
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok,
+            })));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        var installs = payload["installs"]!.AsArray();
+        Assert.Single(installs);
+        Assert.Equal(installPath, installs[0]!["path"]!.GetValue<string>());
+    }
+
     [Fact]
     public async Task Info_ChannelLocal_IsNotTreatedAsFailure()
     {

From 06467640c4af29d16edb430d2391303ceedb41a2 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 01:25:29 -0400
Subject: [PATCH 11/15] fix(cli): prevent duplicate `id` values in `aspire
 --info` output
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The unique-id minter in `InstallationInfoOutput.GetUniqueIdCore`
counted collisions on the base id only and never reserved the suffixed
name it returned. Two rows could therefore share an `id` when one row's
natural base id happened to match another row's disambiguation suffix:

    1st  "stable"                       → "stable"
    2nd  "stable"                       → "stable-2"  (suffix NOT recorded)
    orphan hive literally "stable-2"    → "stable-2"  (silent collision)

The orphan-hive base id is the directory name under `~/.aspire/hives/`,
which is not constrained to the `IdentityChannelReader` allowlist on
the enumeration path, so user-created (or installer-quirk) hive names
can naturally land on a `<channel>-N` shape. JSON consumers that key on
`id` (the documented purpose of the field) silently merge or overwrite
the colliding rows.

Loop the suffix counter until the candidate is unused, then record both
the bumped per-base counter and the candidate itself so future natural
ids can't recreate it.

Added a regression test exercising two `winget` installs sharing
channel `stable` plus an orphan-hive directory named `stable-2`; the
test fails on the pre-fix code (orphan ends up sharing `stable-2`) and
passes with the fix (orphan gets `stable-2-2`).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Commands/InstallationInfoOutput.cs        | 22 +++++-
 .../Commands/InfoOptionTests.cs               | 68 +++++++++++++++++++
 2 files changed, 88 insertions(+), 2 deletions(-)

diff --git a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
index 5bcda1e7561..2e1109a5cb4 100644
--- a/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
+++ b/src/Aspire.Cli/Commands/InstallationInfoOutput.cs
@@ -241,9 +241,27 @@ private static string GetUniqueIdCore(string id, Dictionary<string, int> ids)
             return id;
         }
 
-        count++;
+        // Increment the per-base counter and verify the suffixed candidate is
+        // not itself already taken. Without this loop, two rows can collide
+        // when one row's natural base id happens to match another row's
+        // disambiguation suffix — e.g. two installs reporting channel "stable"
+        // produce ids "stable" and "stable-2", and an orphan-hive directory
+        // literally named "stable-2" (hive names are arbitrary user-controlled
+        // directory names under ~/.aspire/hives/) would otherwise mint a
+        // second "stable-2" because the suffix was never recorded in `ids`.
+        // We record both the bumped per-base counter and the candidate itself
+        // so future bases can't recreate the suffix.
+        string candidate;
+        do
+        {
+            count++;
+            candidate = $"{id}-{count}";
+        }
+        while (ids.ContainsKey(candidate));
+
         ids[id] = count;
-        return $"{id}-{count}";
+        ids[candidate] = 1;
+        return candidate;
     }
 
     private static string GetInstallKind(InstallationInfo install)
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index 53537904e88..a35849c1e3f 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -521,6 +521,74 @@ public async Task Info_Json_IncludesDiscoveredInstallsBrokenRowsAndOrphanHives()
             });
     }
 
+    [Fact]
+    public async Task Info_Json_DisambiguatorReservesSuffixedIdsToAvoidCollisionWithNaturalIds()
+    {
+        // Regression guard: previously the unique-id minter only counted
+        // collisions on the base id and never reserved the suffixed name.
+        // Two installs sharing channel "stable" produced ids "stable" and
+        // "stable-2", and an orphan-hive directory literally named "stable-2"
+        // (hive directory names are arbitrary, not constrained to the
+        // IdentityChannelReader allowlist on the enumeration path) silently
+        // got the same id "stable-2", violating the uniqueness invariant of
+        // the `id` field that JSON consumers use as a key.
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var aspireHome = Path.Combine(workspace.WorkspaceRoot.FullName, ".aspire");
+        Directory.CreateDirectory(Path.Combine(aspireHome, "hives", "stable-2", "packages"));
+
+        var outputWriter = new TestOutputTextWriter(outputHelper);
+        var services = CliTestHelper.CreateServiceCollection(workspace, outputHelper, options =>
+        {
+            options.OutputTextWriter = outputWriter;
+            options.DisableAnsi = true;
+        });
+        services.Replace(ServiceDescriptor.Singleton<IInstallationDiscovery>(_ => new FakeInstallationDiscovery(
+            new InstallationInfo
+            {
+                Path = Path.Combine(aspireHome, "bin", "aspire"),
+                CanonicalPath = Path.Combine(aspireHome, "bin", "aspire"),
+                Version = "13.2.0",
+                Channel = "stable",
+                // Source is intentionally not "script": GetInstallId short-circuits
+                // to the literal "script" for script-sourced installs, which would
+                // hide the channel-keyed disambiguation path this test exercises.
+                Source = "winget",
+                PathStatus = InstallationPathStatus.Active,
+                Status = InstallationInfoStatus.Ok
+            },
+            [
+                new InstallationInfo
+                {
+                    Path = Path.Combine(aspireHome, "other", "aspire"),
+                    CanonicalPath = Path.Combine(aspireHome, "other", "aspire"),
+                    Version = "13.2.0",
+                    Channel = "stable",
+                    Source = "winget",
+                    PathStatus = InstallationPathStatus.Shadowed,
+                    Status = InstallationInfoStatus.Ok
+                }
+            ])));
+        using var provider = services.BuildServiceProvider();
+
+        var command = provider.GetRequiredService<RootCommand>();
+        var result = command.Parse("--info --format json");
+
+        var exitCode = await result.InvokeAsync().DefaultTimeout();
+
+        Assert.Equal(CliExitCodes.Success, exitCode);
+        var payload = JsonNode.Parse(string.Join(Environment.NewLine, outputWriter.Logs))!.AsObject();
+        var installs = payload["installs"]!.AsArray();
+        var ids = installs.Select(row => row!["id"]!.GetValue<string>()).ToList();
+        Assert.Equal(3, ids.Count);
+        Assert.Equal(ids.Count, ids.Distinct(StringComparer.Ordinal).Count());
+        // The orphan-hive row whose natural id collides with the disambiguation
+        // suffix must receive its own disambiguated id rather than silently
+        // sharing "stable-2" with the second install.
+        Assert.Contains("stable", ids);
+        Assert.Contains("stable-2", ids);
+        Assert.Contains(ids, id => id.StartsWith("stable-2-", StringComparison.Ordinal));
+    }
+
     [Fact]
     public async Task Info_DiscoveryWalkFails_StillExitsZero_AndEmitsFailureRow()
     {

From c21a614ad74c3da1ab2eed3b166fab888e5b4a44 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 01:34:21 -0400
Subject: [PATCH 12/15] test(cli): pin rendered `--self`/`--format` token in
 parse-error messages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`ValidateRequiresInfo` formats the offending option using `option.Name`.
System.CommandLine 2.0.8 returns the full token including the leading
`--` (e.g. `--self`), so the rendered message reads:

    Option `--self` is only valid when `--info` is also specified.

A future SCL upgrade that changed `Name` semantics to strip the dashes
would silently degrade the message to the ungrammatical "Option `self`
is only valid when..." with no test failure today, because the existing
parse-error tests only check that `result.Errors` is non-empty.

Strengthen `Info_SelfWithoutInfo_FailsParse` and
`Info_FormatWithoutInfo_FailsParse` to assert the error text contains
``--self`` / ``--format`` (the token form, backticks included). This is
the same shape other consumers in the repo already rely on
(`BaseCommand.cs` checks `option.Name == "--format"`,
`GroupedHelpWriter.cs` calls `option.Name.StartsWith("--", ...)`), so
an SCL change in this area would break multiple call sites — the new
assertion just surfaces it on the user-visible path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index a35849c1e3f..533d3bc180f 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -981,6 +981,13 @@ public void Info_SelfWithoutInfo_FailsParse()
         var result = command.Parse("--self");
 
         Assert.NotEmpty(result.Errors);
+        // The validator formats the offending option using `option.Name`,
+        // which System.CommandLine returns including the leading `--` (e.g.
+        // `--self`). Pin the rendered text so a future System.CommandLine
+        // upgrade that changed Name semantics to strip the dashes — and
+        // therefore produced the ungrammatical message "Option `self` is
+        // only valid when ..." — would surface here.
+        Assert.Contains(result.Errors, e => e.Message.Contains("`--self`", StringComparison.Ordinal));
     }
 
     [Fact]
@@ -999,6 +1006,10 @@ public void Info_FormatWithoutInfo_FailsParse()
         var result = command.Parse("--format json");
 
         Assert.NotEmpty(result.Errors);
+        // See the matching assertion in Info_SelfWithoutInfo_FailsParse: pin
+        // the rendered text so an SCL `Name`-semantics change can't silently
+        // strip the leading `--` from the displayed option token.
+        Assert.Contains(result.Errors, e => e.Message.Contains("`--format`", StringComparison.Ordinal));
     }
 
     [Fact]

From f174ca14248410d5d22fa1a69481306fda0bec04 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 02:17:52 -0400
Subject: [PATCH 13/15] test(cli): route Azure-Monitor-enabled --info gate
 tests through host lifecycle
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`AzureMonitor_Enabled_WhenInfoFlagOnSubcommand` was constructing
`TelemetryManager` directly:

    var configuration = new ConfigurationBuilder().Build();
    var manager = new TelemetryManager(configuration, args);
    Assert.True(manager.HasAzureMonitor);

Because the args (`"run", "--info"` etc.) do not trip the informational
opt-out, this builds a real Azure Monitor `TracerProvider` and registers
a process-wide `ActivityListener` on `Aspire.Cli.Reported`. The manager
is never disposed, and even with `using` would not be — `TelemetryManager.Dispose`
only calls `Shutdown(0)` on the providers (see comment on
`TelemetryManager.cs:208`), which does not unregister the listener.

Across parallel test classes the leaked listener intercepts reported
activities from unrelated tests (`AddCommand`, `NewCommand`,
`RunCommand`, ...), and concurrent invocations race on
`ActivityCreationOptions.SamplingTags.Add("microsoft.sample_rate", ...)`
(Azure Monitor's `RateLimitedSampler` uses `Add`, not `TryAdd`),
throwing the same exception the test process tries to surface as the
failing test:

    ❌ An unexpected error occurred: "The collection already contains
       item with same key 'microsoft.sample_rate'"

This is the same race tracked by microsoft/aspire#17450. The fix in
e126a1ab8 (process-wide telemetry opt-out + opted-in tests routing
through `BuildHostAsync`) keeps existing Azure-Monitor-enabled tests on
`main` clean — they all go through DI disposal. The new tests on this
branch bypassed that lifecycle and resurrected the race.

Route the new test through `BuildHostAsync` like the surrounding
`AzureMonitor_Enabled_ByDefault` test. `BuildHostAsync` now accepts an
optional `args` parameter that is threaded into
`Program.BuildApplicationAsync`, so the position-aware
`IsInformationalInvocation` gate still gets exercised with the
non-informational subcommand-plus-`--info` shapes. `WithTelemetryOptIn`
undoes the process-wide opt-out (`TestTelemetryDefaults`) so Azure
Monitor is actually built — same lifecycle pattern as
`AzureMonitor_Enabled_ByDefault`.

The two new opted-OUT tests (`AzureMonitor_Disabled_WhenInfoFlagProvided`,
`AzureMonitor_Disabled_WhenRecursiveInformationalFlagOnSubcommand`)
stay on direct construction: they short-circuit before building a
TracerProvider, so there is no listener to leak.

The underlying bug in `TelemetryManager.Dispose` is pre-existing and
out of scope for this PR — filed separately.

Verified locally: three consecutive full Aspire.Cli.Tests runs all pass
3864/3864 with zero `sample_rate` failures. Before this change the same
runs surfaced 20-60 `sample_rate`-flavored failures each.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Telemetry/TelemetryConfigurationTests.cs  | 32 +++++++++++++------
 1 file changed, 23 insertions(+), 9 deletions(-)

diff --git a/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs b/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs
index 3508df92548..58ce5fe5ff0 100644
--- a/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs
+++ b/tests/Aspire.Cli.Tests/Telemetry/TelemetryConfigurationTests.cs
@@ -34,14 +34,14 @@ public class TelemetryConfigurationTests
         return result;
     }
 
-    private static async Task<IHost> BuildHostAsync(Dictionary<string, string?>? config = null)
+    private static async Task<IHost> BuildHostAsync(Dictionary<string, string?>? config = null, string[]? args = null)
     {
         var loggingOptions = Program.ParseLoggingOptions([]);
         var errorWriter = new TestStartupErrorWriter();
         var logBufferContext = new ConsoleLogBufferContext();
         var (loggerFactory, fileLoggerProvider) = Program.CreateLoggerFactory([], loggingOptions, errorWriter, logBufferContext);
         var startupContext = new Program.CliStartupContext(loggingOptions, errorWriter, loggerFactory, fileLoggerProvider, logBufferContext, loggerFactory.CreateLogger(Program.RootLoggerName));
-        return await Program.BuildApplicationAsync([], startupContext, config);
+        return await Program.BuildApplicationAsync(args ?? [], startupContext, config);
     }
 
     [Fact]
@@ -206,8 +206,11 @@ public void AzureMonitor_Disabled_ForAllHelpFlags(string flag)
     }
 
     [Fact]
-    public void AzureMonitor_Disabled_WhenInfoFlagProvided()
+    public async Task AzureMonitor_Disabled_WhenInfoFlagProvided()
     {
+        // No args other than --info: the informational gate opts out, so no
+        // Azure Monitor TracerProvider is built and no ActivityListener is
+        // registered — safe to construct directly even without a host.
         var configuration = new ConfigurationBuilder().Build();
 
         var manager = new TelemetryManager(configuration, ["--info"]);
@@ -219,17 +222,27 @@ public void AzureMonitor_Disabled_WhenInfoFlagProvided()
     [InlineData("run", "--info")]
     [InlineData("new", "--info")]
     [InlineData("publish", "--info", "--format", "json")]
-    public void AzureMonitor_Enabled_WhenInfoFlagOnSubcommand(params string[] args)
+    public async Task AzureMonitor_Enabled_WhenInfoFlagOnSubcommand(params string[] args)
     {
         // --info is intentionally root-only / non-recursive (see InfoOptionTests'
         // Info_OnSubcommand_DoesNotFireInfoAction). A subcommand invocation that
         // carries --info is a real subcommand invocation, so reported telemetry
         // must not be silently opted out for it.
-        var configuration = new ConfigurationBuilder().Build();
-
-        var manager = new TelemetryManager(configuration, args);
+        //
+        // This branch actually builds an Azure Monitor TracerProvider, which
+        // registers a process-wide ActivityListener on `Aspire.Cli.Reported`.
+        // Routing through BuildHostAsync(+ WithTelemetryOptIn to undo the
+        // process-wide test opt-out from TestTelemetryDefaults) ensures the
+        // TelemetryManager goes through DI disposal when the host is disposed,
+        // matching the lifecycle of AzureMonitor_Enabled_ByDefault. Direct
+        // construction with `new TelemetryManager(...)` would not be disposed
+        // by `using` either — TelemetryManager.Dispose only Shutdown(0)s the
+        // providers — but accumulating bare instances across parallel test
+        // classes can surface microsoft/aspire#17450's sample_rate race.
+        using var host = await BuildHostAsync(WithTelemetryOptIn(), args);
 
-        Assert.True(manager.HasAzureMonitor);
+        var telemetryManager = host.Services.GetRequiredService<TelemetryManager>();
+        Assert.True(telemetryManager.HasAzureMonitor);
     }
 
     [Theory]
@@ -240,7 +253,8 @@ public void AzureMonitor_Disabled_WhenRecursiveInformationalFlagOnSubcommand(par
     {
         // --help / --version are recursive in System.CommandLine, so e.g.
         // `aspire run --help` is genuinely a help invocation. The gate must
-        // keep opting out of telemetry for them at any depth.
+        // keep opting out of telemetry for them at any depth. Opted out =>
+        // no TracerProvider built, so direct construction is safe here too.
         var configuration = new ConfigurationBuilder().Build();
 
         var manager = new TelemetryManager(configuration, args);

From dafaf4f5f8dada4614a24ca220ca88e9ee1dcd73 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 03:04:08 -0400
Subject: [PATCH 14/15] review(cli): address Copilot review pass on
 installs-discovery PR
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three findings from the latest Copilot review pass on PR #17461:

1. `WingetSidecarBackfillStartupTests.cs` — `CapturingWindowsRegistryReader`
   XML doc claimed returning `false` from the reader meant "the probe does
   not write a sidecar", which is the opposite of what the code does:
   returning `false` is exactly what drives `WingetSidecarBackfill` down
   the negative-result arm that writes the `{"backfilled":true}` sentinel.
   Rewrite the doc to describe the actual contract.

2. `WingetSidecarBackfillStartupTests.cs` — the test's
   `AssertBackfillReachableFromTestRunner` skip path silently dropped
   coverage on Windows.

   Root cause: `Program.TryEnsureWingetSidecar` derives `binaryDir` from
   `Environment.ProcessPath`, and the `CliExecutionContext` DI factory
   invokes it on every resolution. Tests that build a real host via
   `Program.BuildApplicationAsync` and resolve `CliExecutionContext`
   (e.g. `CliBootstrapTests`) trigger the back-fill on Windows, writing
   `.aspire-install.json` into the testhost binary directory. After that
   write, `WingetSidecarBackfillStartupTests`'s `File.Exists` precondition
   fires and the assertion path is skipped — silently, with no failure.
   The sentinel also persists across `dotnet test --no-build` invocations
   because build-output `bin/...` is not purged between runs.

   Fix: thread the running binary's process path through as an explicit
   parameter. Add an `internal static TryEnsureWingetSidecar(sp, processPath)`
   overload on `Program` and an `internal EnsureSidecar(binaryDir, processPath)`
   overload on `WingetSidecarBackfill`; the existing public/no-arg overloads
   delegate with `Environment.ProcessPath`. `EnsureSidecar` no longer reads
   `Environment.ProcessPath` mid-method, so `binaryDir` and the registry
   probe argument are guaranteed consistent for any caller. Production
   call site at `Program.cs:377` is unchanged.

   Rewrite `WingetSidecarBackfillStartupTests` to use a per-test temp
   directory via `TestTempDirectory` and a synthesized fake binary path,
   drop `AssertBackfillReachableFromTestRunner` and the silent-skip path
   entirely, and assert the registry probe sees the same fake path. The
   "DI factory binds binaryDir to `Environment.ProcessPath`" claim becomes
   a one-line delegating expression at the no-arg overload, below the
   threshold of needing dedicated coverage.

   Leave a breadcrumb in `CliBootstrapTests.BuildHostAsync` so the next
   person debugging a stray `.aspire-install.json` in the testhost binary
   directory on Windows finds the cause.

3. `eng/scripts/verify-cli-tool-nupkg.ps1` — wording fix: "so the CLI can
   source `aspire update --self`" implied the CLI is sourcing a script.
   Should be "route" — the sidecar's `source` field is what lets the CLI
   route the self-update command to the dotnet-tool delegate.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 eng/scripts/verify-cli-tool-nupkg.ps1         |   2 +-
 .../Acquisition/WingetSidecarBackfill.cs      |  11 +-
 src/Aspire.Cli/Program.cs                     |  14 +-
 .../WingetSidecarBackfillStartupTests.cs      | 147 +++++-------------
 tests/Aspire.Cli.Tests/CliBootstrapTests.cs   |   7 +
 5 files changed, 67 insertions(+), 114 deletions(-)

diff --git a/eng/scripts/verify-cli-tool-nupkg.ps1 b/eng/scripts/verify-cli-tool-nupkg.ps1
index dc5fd412074..05631987e78 100644
--- a/eng/scripts/verify-cli-tool-nupkg.ps1
+++ b/eng/scripts/verify-cli-tool-nupkg.ps1
@@ -226,7 +226,7 @@ try {
     }
 
     # The RID-specific tool nupkg is always installed via `dotnet tool install -g`.
-    # The sidecar's source must pin to 'dotnet-tool' so the CLI can source
+    # The sidecar's source must pin to 'dotnet-tool' so the CLI can route
     # `aspire update --self` to the correct delegating command. Other source
     # values would mis-identify the install and break self-update.
     if ([string]$sidecarJson.source -ne 'dotnet-tool') {
diff --git a/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs b/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
index 7bb81246eed..61f1e5627de 100644
--- a/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
+++ b/src/Aspire.Cli/Acquisition/WingetSidecarBackfill.cs
@@ -81,6 +81,16 @@ public WingetSidecarBackfill(IWindowsRegistryReader registry, ILogger<WingetSide
     /// Idempotent: an existing sidecar is never overwritten.
     /// </summary>
     public void EnsureSidecar(string binaryDir)
+        => EnsureSidecar(binaryDir, Environment.ProcessPath);
+
+    /// <summary>
+    /// Test seam for <see cref="EnsureSidecar(string)"/>: takes the running
+    /// binary path as an explicit parameter rather than reading
+    /// <see cref="Environment.ProcessPath"/>, so tests can pin both the write
+    /// target and the registry-probe argument to a controlled value. Production
+    /// callers go through the single-arg overload.
+    /// </summary>
+    internal void EnsureSidecar(string binaryDir, string? processPath)
     {
         // The back-fill exists solely to amortize a HKCU + HKLM Uninstall hive walk
         // that only makes sense on Windows; on Linux/macOS there is no registry to
@@ -104,7 +114,6 @@ public void EnsureSidecar(string binaryDir)
             return;
         }
 
-        var processPath = Environment.ProcessPath;
         if (string.IsNullOrEmpty(processPath))
         {
             return;
diff --git a/src/Aspire.Cli/Program.cs b/src/Aspire.Cli/Program.cs
index 5a9e4b70a01..53bf9b57569 100644
--- a/src/Aspire.Cli/Program.cs
+++ b/src/Aspire.Cli/Program.cs
@@ -653,10 +653,20 @@ private static CliExecutionContext BuildCliExecutionContextCore(bool debugMode,
     /// before any code reads it.
     /// </summary>
     internal static void TryEnsureWingetSidecar(IServiceProvider sp)
+        => TryEnsureWingetSidecar(sp, Environment.ProcessPath);
+
+    /// <summary>
+    /// Test seam for <see cref="TryEnsureWingetSidecar(IServiceProvider)"/>:
+    /// takes the running binary path as an explicit parameter so tests can
+    /// target a temp directory instead of <see cref="Environment.ProcessPath"/>,
+    /// which would otherwise land the sidecar in the testhost binary directory
+    /// and silently bias parallel tests that read from the same location.
+    /// Production callers go through the single-arg overload.
+    /// </summary>
+    internal static void TryEnsureWingetSidecar(IServiceProvider sp, string? processPath)
     {
         try
         {
-            var processPath = Environment.ProcessPath;
             if (string.IsNullOrEmpty(processPath))
             {
                 return;
@@ -668,7 +678,7 @@ internal static void TryEnsureWingetSidecar(IServiceProvider sp)
                 return;
             }
 
-            sp.GetRequiredService<WingetSidecarBackfill>().EnsureSidecar(binaryDir);
+            sp.GetRequiredService<WingetSidecarBackfill>().EnsureSidecar(binaryDir, processPath);
         }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
diff --git a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
index c0858713cb9..c9c60ace96c 100644
--- a/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
+++ b/tests/Aspire.Cli.Tests/Acquisition/WingetSidecarBackfillStartupTests.cs
@@ -16,48 +16,46 @@ namespace Aspire.Cli.Tests.Acquisition;
 /// The back-fill is fired exactly once from <see cref="Program.TryEnsureWingetSidecar(IServiceProvider)"/>,
 /// which is itself called from the <c>CliExecutionContext</c> DI singleton factory in
 /// <c>Program.BuildApplicationAsync</c>. The "factory invokes this helper" claim is a one-line
-/// code-review check at the factory body; the helper's own contract (resolves the back-fill, derives
-/// the binary directory from <see cref="Environment.ProcessPath"/>, swallows failures) is what is
-/// pinned here.
+/// code-review check at the factory body; the helper's own contract (resolves the back-fill from
+/// DI, derives the binary directory from the supplied process path, swallows failures, and threads
+/// the same process path through to the registry probe) is what is pinned here.
 /// </para>
 /// <para>
-/// The back-fill early-returns when the sidecar already exists at the target binary directory.
-/// In a normal test run the test host binary directory (the dotnet install root) carries no
-/// sidecar, but a stray sidecar would silently turn these tests into no-ops. Each test checks
-/// that precondition explicitly and skips with a diagnostic message otherwise.
+/// Tests use the two-arg test-seam overload (<see cref="Program.TryEnsureWingetSidecar(IServiceProvider, string?)"/>)
+/// with a fake binary under a per-test temp directory so the sidecar write never touches the
+/// testhost binary directory. That keeps these tests race-free against any other test in the
+/// suite that resolves <c>CliExecutionContext</c> via <c>Program.BuildApplicationAsync</c> on
+/// Windows (e.g. <c>CliBootstrapTests</c>), which would otherwise pre-populate the testhost
+/// binary directory's sidecar via the production singleton factory.
 /// </para>
 /// </remarks>
 public class WingetSidecarBackfillStartupTests
 {
     [Fact]
-    public void TryEnsureWingetSidecar_InvokesBackfillAgainstProcessBinaryDirectory()
+    public void TryEnsureWingetSidecar_InvokesBackfillAgainstSuppliedProcessPath()
     {
         Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is a Windows-only back-fill; off Windows it early-returns before resolving DI.");
 
-        var sidecarPath = AssertBackfillReachableFromTestRunner();
+        using var workspace = new TestTempDirectory();
+        var fakeBinaryPath = Path.Combine(workspace.Path, "aspire.exe");
 
         var registry = new CapturingWindowsRegistryReader();
         using var provider = BuildMinimalProvider(registry);
 
-        try
-        {
-            Program.TryEnsureWingetSidecar(provider);
-
-            // The back-fill reached the registry-check arm exactly once, which means it
-            // resolved WingetSidecarBackfill from DI, derived the binary directory from
-            // Environment.ProcessPath, found no pre-existing sidecar, and queried our
-            // capturing reader for ARP membership. Returning false from the reader
-            // means the back-fill wrote the negative-result sentinel
-            // (`{"backfilled":true}`) near the test runner's binary; the finally block
-            // below deletes it so subsequent test runs aren't short-circuited by the
-            // existing-sidecar fast path.
-            Assert.Equal(1, registry.CallCount);
-            Assert.Equal(Environment.ProcessPath, registry.LastProcessPath);
-        }
-        finally
-        {
-            TryDeleteBackfilledSentinel(sidecarPath);
-        }
+        Program.TryEnsureWingetSidecar(provider, fakeBinaryPath);
+
+        // The back-fill reached the registry-check arm exactly once, which means it
+        // resolved WingetSidecarBackfill from DI, derived the binary directory from
+        // the supplied process path, found no pre-existing sidecar, and queried our
+        // capturing reader for ARP membership using the same process path. Returning
+        // false from the reader means the back-fill wrote the negative-result
+        // sentinel (`{"backfilled":true}`) into the temp workspace; TestTempDirectory
+        // cleans it up on dispose so nothing leaks into the testhost binary directory.
+        Assert.Equal(1, registry.CallCount);
+        Assert.Equal(fakeBinaryPath, registry.LastProcessPath);
+
+        var sidecarPath = Path.Combine(workspace.Path, InstallSidecarReader.SidecarFileName);
+        Assert.True(File.Exists(sidecarPath), $"Expected sidecar at '{sidecarPath}' after back-fill.");
     }
 
     [Fact]
@@ -65,89 +63,16 @@ public void TryEnsureWingetSidecar_SwallowsRegistryReaderException()
     {
         Assert.SkipUnless(OperatingSystem.IsWindows(), "WingetSidecarBackfill is a Windows-only back-fill; off Windows it early-returns before consulting the registry reader, so a throwing reader is unreachable.");
 
-        var sidecarPath = AssertBackfillReachableFromTestRunner();
+        using var workspace = new TestTempDirectory();
+        var fakeBinaryPath = Path.Combine(workspace.Path, "aspire.exe");
 
         using var provider = BuildMinimalProvider(new ThrowingWindowsRegistryReader());
 
-        try
-        {
-            // No exception must escape: a registry probe failure during CLI startup
-            // is logged and treated as "not a winget install for this run", not a
-            // fatal error that prevents the CLI from launching.
-            var ex = Record.Exception(() => Program.TryEnsureWingetSidecar(provider));
-            Assert.Null(ex);
-        }
-        finally
-        {
-            // The throwing reader runs before any write attempt, so in normal
-            // execution no sentinel is written here — but a previous test
-            // failure or an interleaved run might have left one. Clean up
-            // defensively so the next test reaches the registry reader.
-            TryDeleteBackfilledSentinel(sidecarPath);
-        }
-    }
-
-    /// <summary>
-    /// Skips the test if <see cref="Environment.ProcessPath"/> is unavailable or
-    /// if a stray <c>.aspire-install.json</c> exists at the test host's binary
-    /// directory. Either condition would make the back-fill early-return before
-    /// reaching the registry reader, which would silently invalidate the assertion.
-    /// Returns the resolved sidecar path so the caller can clean it up after the run.
-    /// </summary>
-    private static string AssertBackfillReachableFromTestRunner()
-    {
-        var processPath = Environment.ProcessPath;
-        Assert.SkipUnless(
-            !string.IsNullOrEmpty(processPath),
-            "Environment.ProcessPath is unavailable in this test host; the startup back-fill cannot run.");
-
-        var binaryDir = Path.GetDirectoryName(processPath);
-        Assert.SkipUnless(
-            !string.IsNullOrEmpty(binaryDir),
-            $"Could not derive a binary directory from Environment.ProcessPath='{processPath}'.");
-
-        var sidecarPath = Path.Combine(binaryDir, InstallSidecarReader.SidecarFileName);
-        Assert.SkipUnless(
-            !File.Exists(sidecarPath),
-            $"Test host binary directory '{binaryDir}' already contains '{InstallSidecarReader.SidecarFileName}'; the back-fill would early-return before consulting the registry. " +
-            "Remove the stray sidecar or run the tests from a different host to exercise this scenario.");
-
-        return sidecarPath;
-    }
-
-    /// <summary>
-    /// Deletes the negative-result sentinel that <see cref="WingetSidecarBackfill.EnsureSidecar"/>
-    /// writes next to the test runner binary when <see cref="IWindowsRegistryReader.HasWingetAspireUninstallEntry"/>
-    /// returns <see langword="false"/>. Without this, the sentinel persists in the build
-    /// output and the back-fill's fast path short-circuits every subsequent run of these
-    /// tests. Failures are tolerated so test cleanup never masks the test's real failure.
-    /// </summary>
-    private static void TryDeleteBackfilledSentinel(string sidecarPath)
-    {
-        if (!File.Exists(sidecarPath))
-        {
-            return;
-        }
-
-        try
-        {
-            // Only delete what we wrote. A pre-existing sidecar (e.g. a real winget
-            // install) is filtered out by AssertBackfillReachableFromTestRunner's
-            // File.Exists skip, so anything we find here is a sentinel we wrote
-            // ourselves — but check the content anyway in case a parallel test
-            // wrote a different payload.
-            var content = File.ReadAllText(sidecarPath);
-            if (content.Contains("\"backfilled\":true", StringComparison.Ordinal))
-            {
-                File.Delete(sidecarPath);
-            }
-        }
-        catch (IOException)
-        {
-        }
-        catch (UnauthorizedAccessException)
-        {
-        }
+        // No exception must escape: a registry probe failure during CLI startup
+        // is logged and treated as "not a winget install for this run", not a
+        // fatal error that prevents the CLI from launching.
+        var ex = Record.Exception(() => Program.TryEnsureWingetSidecar(provider, fakeBinaryPath));
+        Assert.Null(ex);
     }
 
     private static ServiceProvider BuildMinimalProvider(IWindowsRegistryReader registry)
@@ -167,8 +92,10 @@ private static ServiceProvider BuildMinimalProvider(IWindowsRegistryReader regis
 
 /// <summary>
 /// Captures every <see cref="HasWingetAspireUninstallEntry"/> call and always
-/// returns <see langword="false"/> so the probe does not write a sidecar near
-/// the test host's binary.
+/// reports the WinGet Add/Remove Programs entry is missing. Returning
+/// <see langword="false"/> drives the back-fill down the negative-result arm,
+/// which writes the <c>{"backfilled":true}</c> sentinel to the supplied
+/// binary directory.
 /// </summary>
 file sealed class CapturingWindowsRegistryReader : IWindowsRegistryReader
 {
diff --git a/tests/Aspire.Cli.Tests/CliBootstrapTests.cs b/tests/Aspire.Cli.Tests/CliBootstrapTests.cs
index fee54f57f68..7013e57e18e 100644
--- a/tests/Aspire.Cli.Tests/CliBootstrapTests.cs
+++ b/tests/Aspire.Cli.Tests/CliBootstrapTests.cs
@@ -24,6 +24,13 @@ public class CliBootstrapTests(ITestOutputHelper outputHelper)
 
     private static async Task<IHost> BuildHostAsync()
     {
+        // On Windows, resolving CliExecutionContext through the host built here
+        // fires WingetSidecarBackfill via the singleton factory at Program.cs:350-379,
+        // which writes a `.aspire-install.json` sentinel into the testhost binary
+        // directory. The write is idempotent and harmless to these tests, but any
+        // future test that reads sidecars from `Environment.ProcessPath`'s directory
+        // should expect this side effect — or use a per-test temp directory and the
+        // two-arg test-seam overload of `TryEnsureWingetSidecar`/`EnsureSidecar`.
         var loggingOptions = Program.ParseLoggingOptions([]);
         var errorWriter = new TestStartupErrorWriter();
         var logBufferContext = new ConsoleLogBufferContext();

From e87b52b68e4f03e1be507b07ae8b1db6d0bcccf9 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 27 May 2026 15:07:12 -0400
Subject: [PATCH 15/15] fix(cli): escape Markdown special chars in `aspire
 --info` row headings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`aspire --info` renders one heading line per discovered install via
`DisplayMarkdown($"**{row.Id}**  {row.Kind}")`. For sidecar-less installs
`row.Id` falls back to `install.Path` (see
`InstallationInfoOutput.GetInstallId`), which on Windows looks like
`C:\Users\<user>\.aspire\bin\aspire.exe`. CommonMark treats any `\`
followed by ASCII punctuation as a backslash-escape and drops the
backslash, so the heading rendered as
`C:\Users\<user>.aspire\bin\aspire.exe` — silently corrupting the
diagnostic surface a user reaches for to figure out where their CLI
actually lives.

Escape ASCII punctuation in `row.Id` and `row.Kind` before they reach
the Markdown renderer. The escape covers the full CommonMark ASCII
punctuation range so other punctuation in unexpected paths, hive names,
or future install kinds doesn't reintroduce the same class of bug.

Round-trip test pins the contract: each test input is escaped, fed
through `MarkdownToSpectreConverter.ConvertToPlainText` (the same
renderer used for redirected/non-interactive `--info` output), and the
result must equal the original literal.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Aspire.Cli/Commands/InfoOptionAction.cs   | 50 ++++++++++++++++++-
 .../Commands/InfoOptionTests.cs               | 29 +++++++++++
 2 files changed, 78 insertions(+), 1 deletion(-)

diff --git a/src/Aspire.Cli/Commands/InfoOptionAction.cs b/src/Aspire.Cli/Commands/InfoOptionAction.cs
index cf78eef6736..c487fe5d5f5 100644
--- a/src/Aspire.Cli/Commands/InfoOptionAction.cs
+++ b/src/Aspire.Cli/Commands/InfoOptionAction.cs
@@ -3,6 +3,7 @@
 
 using System.CommandLine;
 using System.CommandLine.Invocation;
+using System.Text;
 using System.Text.Json;
 using Aspire.Cli.Acquisition;
 using Aspire.Cli.Interaction;
@@ -152,7 +153,15 @@ private async Task<int> WriteFullInfoAsync(InfoOutputFormat format, Cancellation
 
         foreach (var row in rows)
         {
-            _interactionService.DisplayMarkdown($"**{row.Id}**  {row.Kind}");
+            // row.Id and row.Kind are derived from install metadata that can
+            // include user/environment paths. For sidecar-less installs, row.Id
+            // falls back to install.Path (see InstallationInfoOutput.GetInstallId),
+            // which on Windows looks like `C:\Users\<user>\.aspire\bin\aspire.exe`.
+            // CommonMark treats `\` followed by ASCII punctuation as an escape
+            // and drops the backslash, so an unescaped path renders as
+            // `C:\Users\<user>.aspire\bin\aspire.exe`. Escape Markdown special
+            // characters in both fields before they reach the renderer.
+            _interactionService.DisplayMarkdown($"**{EscapeMarkdown(row.Id)}**  {EscapeMarkdown(row.Kind)}");
             DisplayField("Status", row.Status);
             DisplayField("Channel", row.Channel);
             DisplayField("Version", row.Version);
@@ -220,4 +229,43 @@ private void DisplayField(string name, string? value)
 
         _interactionService.DisplayPlainText($"  {name,-8} {value}");
     }
+
+    /// <summary>
+    /// Escapes a value so it can be safely embedded in the Markdown text
+    /// passed to <see cref="IInteractionService.DisplayMarkdown"/> without
+    /// being interpreted as formatting or a CommonMark escape sequence.
+    /// </summary>
+    /// <remarks>
+    /// CommonMark allows any ASCII punctuation character to be backslash-escaped
+    /// (<see href="https://spec.commonmark.org/0.31.2/#backslash-escapes"/>),
+    /// and the renderer silently drops the backslash. Without this, a value like
+    /// <c>C:\Users\dapine\.aspire\bin\aspire.exe</c> renders as
+    /// <c>C:\Users\dapine.aspire\bin\aspire.exe</c> because the renderer treats
+    /// each <c>\</c> followed by punctuation as an escape. Prefix each ASCII
+    /// punctuation character with <c>\</c> so the renderer emits the literal
+    /// character.
+    /// </remarks>
+    internal static string EscapeMarkdown(string? value)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return value ?? string.Empty;
+        }
+
+        var sb = new StringBuilder(value.Length + 8);
+        foreach (var c in value)
+        {
+            if (c is >= '!' and <= '/'
+                or >= ':' and <= '@'
+                or >= '[' and <= '`'
+                or >= '{' and <= '~')
+            {
+                sb.Append('\\');
+            }
+
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
 }
diff --git a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
index 533d3bc180f..cd8797a37fb 100644
--- a/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
+++ b/tests/Aspire.Cli.Tests/Commands/InfoOptionTests.cs
@@ -1416,6 +1416,35 @@ public async Task Info_TextRendering_DisplaysStatusAndOnPathSeparately()
         Assert.Contains("On PATH  active", output);
     }
 
+    [Theory]
+    [InlineData(@"C:\Users\dapine\.aspire\bin\aspire.exe")]
+    [InlineData(@"D:\Tools\Aspire\Aspire.exe")]
+    [InlineData(@"path*with*asterisks")]
+    [InlineData(@"path_with_underscores")]
+    [InlineData(@"path[with]brackets")]
+    public void EscapeMarkdown_RoundTrip_PreservesLiteralText(string raw)
+    {
+        // row.Id falls back to install.Path when an install has no source and no
+        // channel (see InstallationInfoOutput.GetInstallId), so the heading
+        // `**{row.Id}**  {row.Kind}` is rendering arbitrary user-derived strings
+        // through the Markdown pipeline. CommonMark drops the leading `\` from
+        // backslash-escape sequences (`\.` → `.`, `\_` → `_`, etc.), which on a
+        // Windows path mangles `C:\Users\dapine\.aspire\bin\aspire.exe` into
+        // `C:\Users\dapine.aspire\bin\aspire.exe` in the human `--info` output.
+        // The escape helper must produce Markdown whose plain-text rendering
+        // round-trips back to the original literal value.
+        var escaped = InfoOptionAction.EscapeMarkdown(raw);
+        var rendered = Aspire.Cli.Utils.Markdown.MarkdownToSpectreConverter.ConvertToPlainText(escaped).TrimEnd();
+        Assert.Equal(raw, rendered);
+    }
+
+    [Fact]
+    public void EscapeMarkdown_NullOrEmpty_ReturnsEmpty()
+    {
+        Assert.Equal(string.Empty, InfoOptionAction.EscapeMarkdown(null));
+        Assert.Equal(string.Empty, InfoOptionAction.EscapeMarkdown(string.Empty));
+    }
+
     private sealed class ConstantChannelReader(string channel) : IIdentityChannelReader
     {
         public string ReadChannel() => channel;