From 679eaa393b5b955da6815cad1755264ce18e6d18 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 2 Jan 2026 20:05:33 -0600
Subject: [PATCH 01/20] Factor options to create methods

---
 .../Restore/RestoreCommandDefinition.cs       | 94 +++++++++----------
 1 file changed, 45 insertions(+), 49 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index 429df87574a8..f02009983db9 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -18,12 +18,7 @@ internal static class RestoreCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly Option<IEnumerable<string>> SourceOption = new Option<IEnumerable<string>>("--source", "-s")
-    {
-        Description = CliCommandStrings.CmdSourceOptionDescription,
-        HelpName = CliCommandStrings.CmdSourceOption
-    }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")
-    .AllowSingleArgPerToken();
+    public static readonly Option<IEnumerable<string>> SourceOption = ;
 
     public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Restore");
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
@@ -106,30 +101,55 @@ public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
         return $"-property:RuntimeIdentifiers={string.Join("%3B", convertedRids)}";
     }
 
-    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
+    private static Option<IEnumerable<string>> CreateSourceOption(bool showHelp, bool useShortOptions)
     {
-        if (showHelp && useShortOptions)
+        var option = new Option<IEnumerable<string>>("--source")
         {
-            yield return SourceOption;
-        }
-        else
+            Description = showHelp ? CliCommandStrings.CmdSourceOptionDescription : string.Empty,
+            HelpName = CliCommandStrings.CmdSourceOption
+        }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")  // '%3B' corresponds to ';'
+         .AllowSingleArgPerToken();
+
+        if (useShortOptions)
         {
-            Option<IEnumerable<string>> sourceOption = new Option<IEnumerable<string>>("--source")
-            {
-                Description = showHelp ? CliCommandStrings.CmdSourceOptionDescription : string.Empty,
-                HelpName = CliCommandStrings.CmdSourceOption,
-                Hidden = !showHelp
-            }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}") // '%3B' corresponds to ';'
-            .AllowSingleArgPerToken();
+            option.Aliases.Add("-s");
+        }
 
-            if (useShortOptions)
-            {
-                sourceOption.Aliases.Add("-s");
-            }
+        return option;
+    }
+
+    private static Option<IEnumerable<string>> CreateRuntimeOption(bool showHelp, bool useShortOptions)
+    {
+        Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime")
+        {
+            Description = CliCommandStrings.CmdRuntimeOptionDescription,
+            HelpName = CliCommandStrings.CmdRuntimeOption,
+            Hidden = !showHelp,
+            IsDynamic = true
+        }.ForwardAsSingle(RestoreRuntimeArgFunc)
+                     .AllowSingleArgPerToken()
+                     .AddCompletions(CliCompletion.RunTimesFromProjectFile);
 
-            yield return sourceOption;
+        if (useShortOptions)
+        {
+            runtimeOption.Aliases.Add("-r");
         }
 
+        return runtimeOption;
+    }
+
+    private static Option<bool> CreateNoDependenciesOption(bool showHelp)
+        => new Option<bool>("--no-dependencies")
+        {
+            Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
+            Arity = ArgumentArity.Zero,
+            Hidden = !showHelp
+        }.ForwardAs("-property:RestoreRecursive=false");
+
+    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
+    {
+        yield return CreateSourceOption(showHelp, useShortOptions);
+
         yield return new Option<string>("--packages")
         {
             Description = showHelp ? CliCommandStrings.CmdPackagesOptionDescription : string.Empty,
@@ -190,33 +210,9 @@ private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool us
         yield return CommonOptions.RestorePropertiesOption;
 
         if (includeRuntimeOption)
-        {
-            Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime")
-            {
-                Description = CliCommandStrings.CmdRuntimeOptionDescription,
-                HelpName = CliCommandStrings.CmdRuntimeOption,
-                Hidden = !showHelp,
-                IsDynamic = true
-            }.ForwardAsSingle(RestoreRuntimeArgFunc)
-             .AllowSingleArgPerToken()
-             .AddCompletions(CliCompletion.RunTimesFromProjectFile);
-
-            if (useShortOptions)
-            {
-                runtimeOption.Aliases.Add("-r");
-            }
-
-            yield return runtimeOption;
-        }
+            yield return CreateRuntimeOption(showHelp, useShortOptions);
 
         if (includeNoDependenciesOption)
-        {
-            yield return new Option<bool>("--no-dependencies")
-            {
-                Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
-                Arity = ArgumentArity.Zero,
-                Hidden = !showHelp
-            }.ForwardAs("-property:RestoreRecursive=false");
-        }
+            yield return CreateNoDependenciesOption(showHelp);
     }
 }

From 72df1425119ff58224e6cc06f7c05248ec8b0d5e Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 2 Jan 2026 20:17:53 -0600
Subject: [PATCH 02/20] Remove include parameters of ImplicitRestoreOptions

---
 .../Commands/Build/BuildCommandDefinition.cs  |  2 +-
 .../Commands/Pack/PackCommandDefinition.cs    |  5 ++--
 .../Publish/PublishCommandDefinition.cs       |  4 +--
 .../Restore/RestoreCommandDefinition.cs       | 25 ++++++++-----------
 4 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index 199e16e5bb58..3876c75beb55 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -65,7 +65,7 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: false);
+        RestoreCommandDefinition.AddImplicitRestoreOptions(command, showHelp: false, useShortOptions: false);
         command.Options.Add(FrameworkOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(RuntimeOption);
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 100b5e42cc39..c8508e76a16e 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -105,8 +105,9 @@ public static Command Create()
         command.Options.Add(CommonOptions.GetTargetResultOption);
         command.Options.Add(CommonOptions.GetResultOutputFileOption);
 
-        // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
+        RestoreCommandDefinition.AddImplicitRestoreOptions(command, showHelp: false, useShortOptions: false);
+
+        command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
         command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
 
         return command;
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index 19603b0b7cbb..c25adac31f1b 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -63,8 +63,8 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
-
+        RestoreCommandDefinition.AddImplicitRestoreOptions(command, showHelp: false, useShortOptions: false);
+        command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
         command.Options.Add(OutputOption);
         command.Options.Add(CommonOptions.ArtifactsPathOption);
         command.Options.Add(ManifestOption);
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index f02009983db9..5df0e8c9b302 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -18,14 +18,14 @@ internal static class RestoreCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly Option<IEnumerable<string>> SourceOption = ;
-
     public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Restore");
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
     public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
 
     private static IEnumerable<Option> FullRestoreOptions() => [
-        ..ImplicitRestoreOptions(true, true, true, true),
+        ..ImplicitRestoreOptions(showHelp: true, useShortOptions: true),
+        CreateRuntimeOption(showHelp: true, useShortOptions: true),
+        CreateNoDependenciesOption(showHelp: true),
         VerbosityOption,
         CommonOptions.InteractiveMsBuildForwardOption,
         CommonOptions.ArtifactsPathOption,
@@ -75,13 +75,14 @@ public static Command Create()
         return command;
     }
 
-    public static void AddImplicitRestoreOptions(Command command, bool showHelp = false, bool useShortOptions = false, bool includeRuntimeOption = true, bool includeNoDependenciesOption = true)
+    public static void AddImplicitRestoreOptions(Command command, bool showHelp, bool useShortOptions)
     {
-        foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions, includeRuntimeOption, includeNoDependenciesOption))
+        foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions))
         {
             command.Options.Add(option);
         }
     }
+
     private static string GetOsFromRid(string rid) => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
     private static string GetArchFromRid(string rid) => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
     public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
@@ -127,8 +128,8 @@ private static Option<IEnumerable<string>> CreateRuntimeOption(bool showHelp, bo
             Hidden = !showHelp,
             IsDynamic = true
         }.ForwardAsSingle(RestoreRuntimeArgFunc)
-                     .AllowSingleArgPerToken()
-                     .AddCompletions(CliCompletion.RunTimesFromProjectFile);
+         .AllowSingleArgPerToken()
+         .AddCompletions(CliCompletion.RunTimesFromProjectFile);
 
         if (useShortOptions)
         {
@@ -138,7 +139,7 @@ private static Option<IEnumerable<string>> CreateRuntimeOption(bool showHelp, bo
         return runtimeOption;
     }
 
-    private static Option<bool> CreateNoDependenciesOption(bool showHelp)
+    public static Option<bool> CreateNoDependenciesOption(bool showHelp)
         => new Option<bool>("--no-dependencies")
         {
             Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
@@ -146,7 +147,7 @@ private static Option<bool> CreateNoDependenciesOption(bool showHelp)
             Hidden = !showHelp
         }.ForwardAs("-property:RestoreRecursive=false");
 
-    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
+    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions)
     {
         yield return CreateSourceOption(showHelp, useShortOptions);
 
@@ -208,11 +209,5 @@ private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool us
 
         yield return CommonOptions.PropertiesOption;
         yield return CommonOptions.RestorePropertiesOption;
-
-        if (includeRuntimeOption)
-            yield return CreateRuntimeOption(showHelp, useShortOptions);
-
-        if (includeNoDependenciesOption)
-            yield return CreateNoDependenciesOption(showHelp);
     }
 }

From e9eb869a8fed639e96e71ec8350959ad9df2046a Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 2 Jan 2026 20:33:19 -0600
Subject: [PATCH 03/20] ImplicitRestoreOptions

---
 .../Commands/Build/BuildCommandDefinition.cs  |   3 +-
 .../Commands/Pack/PackCommandDefinition.cs    |   3 +-
 .../Publish/PublishCommandDefinition.cs       |   3 +-
 .../Restore/ImplicitRestoreOptions.cs         | 119 ++++++++++++++
 .../Restore/RestoreCommandDefinition.cs       | 147 ++++--------------
 5 files changed, 153 insertions(+), 122 deletions(-)
 create mode 100644 src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs

diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index 3876c75beb55..398bde716d78 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -65,7 +65,8 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, showHelp: false, useShortOptions: false);
+        var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
+        implicitOptions.AddTo(command.Options);
         command.Options.Add(FrameworkOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(RuntimeOption);
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index c8508e76a16e..63b0dff2aa91 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -105,7 +105,8 @@ public static Command Create()
         command.Options.Add(CommonOptions.GetTargetResultOption);
         command.Options.Add(CommonOptions.GetResultOutputFileOption);
 
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, showHelp: false, useShortOptions: false);
+        var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
+        implicitOptions.AddTo(command.Options);
 
         command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
         command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index c25adac31f1b..869144b785ed 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -63,7 +63,8 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, showHelp: false, useShortOptions: false);
+        var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
+        implicitOptions.AddTo(command.Options);
         command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
         command.Options.Add(OutputOption);
         command.Options.Add(CommonOptions.ArtifactsPathOption);
diff --git a/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
new file mode 100644
index 000000000000..4cc4c15be215
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
@@ -0,0 +1,119 @@
+// 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.ObjectModel;
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Restore;
+
+internal sealed class ImplicitRestoreOptions
+{
+    public readonly Option<IEnumerable<string>> SourceOption;
+    public readonly Option<string> PackagesOption;
+    public readonly Option<bool> CurrentRuntimeOption;
+    public readonly Option<bool> DisableParallelOption;
+    public readonly Option<string> ConfigFileOption;
+    public readonly Option<bool> NoCacheOption;
+    public readonly Option<bool> NoHttpCacheOption;
+    public readonly Option<bool> IgnoreFailedSourcesOption;
+    public readonly Option<bool> ForceOption;
+    public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption;
+    public readonly Option<ReadOnlyDictionary<string, string>?> RestorePropertiesOption;
+
+    public ImplicitRestoreOptions(bool showHelp, bool useShortOptions)
+    {
+        SourceOption = CreateSourceOption(showHelp, useShortOptions);
+        
+        PackagesOption = new Option<string>("--packages")
+        {
+            Description = showHelp ? CliCommandStrings.CmdPackagesOptionDescription : string.Empty,
+            HelpName = CliCommandStrings.CmdPackagesOption,
+            Hidden = !showHelp
+        }.ForwardAsSingle(o => $"-property:RestorePackagesPath={CommandDirectoryContext.GetFullPath(o)}");
+
+        CurrentRuntimeOption = CommonOptions.CurrentRuntimeOption(CliCommandStrings.CmdCurrentRuntimeOptionDescription);
+
+        DisableParallelOption = new Option<bool>("--disable-parallel")
+        {
+            Description = showHelp ? CliCommandStrings.CmdDisableParallelOptionDescription : string.Empty,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreDisableParallel=true");
+
+        ConfigFileOption = new Option<string>("--configfile")
+        {
+            Description = showHelp ? CliCommandStrings.CmdConfigFileOptionDescription : string.Empty,
+            HelpName = CliCommandStrings.CmdConfigFileOption,
+            Hidden = !showHelp
+        }.ForwardAsSingle(o => $"-property:RestoreConfigFile={CommandDirectoryContext.GetFullPath(o)}");
+
+        NoCacheOption = new Option<bool>("--no-cache")
+        {
+            Description = string.Empty,
+            Hidden = true,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreNoCache=true");
+
+        NoHttpCacheOption = new Option<bool>("--no-http-cache")
+        {
+            Description = showHelp ? CliCommandStrings.CmdNoHttpCacheOptionDescription : string.Empty,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreNoHttpCache=true");
+
+        IgnoreFailedSourcesOption = new Option<bool>("--ignore-failed-sources")
+        {
+            Description = showHelp ? CliCommandStrings.CmdIgnoreFailedSourcesOptionDescription : string.Empty,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreIgnoreFailedSources=true");
+
+        ForceOption = new Option<bool>("--force")
+        {
+            Description = CliCommandStrings.CmdForceRestoreOptionDescription,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreForce=true");
+        if (useShortOptions)
+        {
+            ForceOption.Aliases.Add("-f");
+        }
+
+        PropertiesOption = CommonOptions.PropertiesOption;
+        RestorePropertiesOption = CommonOptions.RestorePropertiesOption;
+    }
+
+    private static Option<IEnumerable<string>> CreateSourceOption(bool showHelp, bool useShortOptions)
+    {
+        var option = new Option<IEnumerable<string>>("--source")
+        {
+            Description = showHelp ? CliCommandStrings.CmdSourceOptionDescription : string.Empty,
+            HelpName = CliCommandStrings.CmdSourceOption,
+            Hidden = !showHelp
+        }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")
+         .AllowSingleArgPerToken();
+
+        if (useShortOptions)
+        {
+            option.Aliases.Add("-s");
+        }
+
+        return option;
+    }
+
+    public void AddTo(IList<Option> options)
+    {
+        options.Add(SourceOption);
+        options.Add(PackagesOption);
+        options.Add(CurrentRuntimeOption);
+        options.Add(DisableParallelOption);
+        options.Add(ConfigFileOption);
+        options.Add(NoCacheOption);
+        options.Add(NoHttpCacheOption);
+        options.Add(IgnoreFailedSourcesOption);
+        options.Add(ForceOption);
+        options.Add(PropertiesOption);
+        options.Add(RestorePropertiesOption);
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index 5df0e8c9b302..f03767f75807 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -22,48 +22,46 @@ internal static class RestoreCommandDefinition
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
     public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
 
-    private static IEnumerable<Option> FullRestoreOptions() => [
-        ..ImplicitRestoreOptions(showHelp: true, useShortOptions: true),
-        CreateRuntimeOption(showHelp: true, useShortOptions: true),
-        CreateNoDependenciesOption(showHelp: true),
-        VerbosityOption,
-        CommonOptions.InteractiveMsBuildForwardOption,
-        CommonOptions.ArtifactsPathOption,
-        new Option<bool>("--use-lock-file")
+    public static Command Create()
+    {
+        var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+
+        var implicitOptions = new ImplicitRestoreOptions(showHelp: true, useShortOptions: true);
+        implicitOptions.AddTo(command.Options);
+
+        command.Options.Add(CreateRuntimeOption(showHelp: true, useShortOptions: true));
+        command.Options.Add(CreateNoDependenciesOption(showHelp: true));
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(new Option<bool>("--use-lock-file")
         {
             Description = CliCommandStrings.CmdUseLockFileOptionDescription,
             Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestorePackagesWithLockFile=true"),
-        new Option<bool>("--locked-mode")
+        }.ForwardAs("-property:RestorePackagesWithLockFile=true"));
+        command.Options.Add(new Option<bool>("--locked-mode")
         {
             Description = CliCommandStrings.CmdLockedModeOptionDescription,
             Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreLockedMode=true"),
-        new Option<string>("--lock-file-path")
+        }.ForwardAs("-property:RestoreLockedMode=true"));
+        command.Options.Add(new Option<string>("--lock-file-path")
         {
             Description = CliCommandStrings.CmdLockFilePathOptionDescription,
             HelpName = CliCommandStrings.CmdLockFilePathOption
-        }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}"),
-        new Option<bool>("--force-evaluate")
+        }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}"));
+        command.Options.Add(new Option<bool>("--force-evaluate")
         {
             Description = CliCommandStrings.CmdReevaluateOptionDescription,
             Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreForceEvaluate=true"),
-        TargetOption,
-        NoLogoOption
-    ];
-
-    public static Command Create()
-    {
-        var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-
-        command.Options.AddRange(FullRestoreOptions());
+        }.ForwardAs("-property:RestoreForceEvaluate=true"));
+        command.Options.Add(TargetOption);
+        command.Options.Add(NoLogoOption);
 
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
@@ -75,14 +73,6 @@ public static Command Create()
         return command;
     }
 
-    public static void AddImplicitRestoreOptions(Command command, bool showHelp, bool useShortOptions)
-    {
-        foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions))
-        {
-            command.Options.Add(option);
-        }
-    }
-
     private static string GetOsFromRid(string rid) => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
     private static string GetArchFromRid(string rid) => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
     public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
@@ -102,23 +92,6 @@ public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
         return $"-property:RuntimeIdentifiers={string.Join("%3B", convertedRids)}";
     }
 
-    private static Option<IEnumerable<string>> CreateSourceOption(bool showHelp, bool useShortOptions)
-    {
-        var option = new Option<IEnumerable<string>>("--source")
-        {
-            Description = showHelp ? CliCommandStrings.CmdSourceOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdSourceOption
-        }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")  // '%3B' corresponds to ';'
-         .AllowSingleArgPerToken();
-
-        if (useShortOptions)
-        {
-            option.Aliases.Add("-s");
-        }
-
-        return option;
-    }
-
     private static Option<IEnumerable<string>> CreateRuntimeOption(bool showHelp, bool useShortOptions)
     {
         Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime")
@@ -146,68 +119,4 @@ public static Option<bool> CreateNoDependenciesOption(bool showHelp)
             Arity = ArgumentArity.Zero,
             Hidden = !showHelp
         }.ForwardAs("-property:RestoreRecursive=false");
-
-    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions)
-    {
-        yield return CreateSourceOption(showHelp, useShortOptions);
-
-        yield return new Option<string>("--packages")
-        {
-            Description = showHelp ? CliCommandStrings.CmdPackagesOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdPackagesOption,
-            Hidden = !showHelp
-        }.ForwardAsSingle(o => $"-property:RestorePackagesPath={CommandDirectoryContext.GetFullPath(o)}");
-
-        yield return CommonOptions.CurrentRuntimeOption(CliCommandStrings.CmdCurrentRuntimeOptionDescription);
-
-        yield return new Option<bool>("--disable-parallel")
-        {
-            Description = showHelp ? CliCommandStrings.CmdDisableParallelOptionDescription : string.Empty,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreDisableParallel=true");
-
-        yield return new Option<string>("--configfile")
-        {
-            Description = showHelp ? CliCommandStrings.CmdConfigFileOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdConfigFileOption,
-            Hidden = !showHelp
-        }.ForwardAsSingle(o => $"-property:RestoreConfigFile={CommandDirectoryContext.GetFullPath(o)}");
-
-        yield return new Option<bool>("--no-cache")
-        {
-            Description = string.Empty,
-            Hidden = true,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreNoCache=true");
-
-        yield return new Option<bool>("--no-http-cache")
-        {
-            Description = showHelp ? CliCommandStrings.CmdNoHttpCacheOptionDescription : string.Empty,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreNoHttpCache=true");
-
-        yield return new Option<bool>("--ignore-failed-sources")
-        {
-            Description = showHelp ? CliCommandStrings.CmdIgnoreFailedSourcesOptionDescription : string.Empty,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreIgnoreFailedSources=true");
-
-        Option<bool> forceOption = new Option<bool>("--force")
-        {
-            Description = CliCommandStrings.CmdForceRestoreOptionDescription,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreForce=true");
-        if (useShortOptions)
-        {
-            forceOption.Aliases.Add("-f");
-        }
-        yield return forceOption;
-
-        yield return CommonOptions.PropertiesOption;
-        yield return CommonOptions.RestorePropertiesOption;
-    }
 }

From 9165a9e078dd92d32aa3f22d24db86aad53d2174 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 2 Jan 2026 20:52:14 -0600
Subject: [PATCH 04/20] Convert fields to Create methods

---
 .../Commands/Build/BuildCommandDefinition.cs  | 26 ++++++------
 .../Commands/Clean/CleanCommandDefinition.cs  | 24 +++++------
 src/Cli/dotnet/Commands/CommandFactory.cs     |  8 ++--
 .../dotnet/Commands/MSBuild/MSBuildCommand.cs |  2 +-
 .../MSBuild/MSBuildCommandDefinition.cs       |  4 +-
 .../Commands/MSBuild/MSBuildForwardingApp.cs  |  2 +-
 .../Commands/Pack/PackCommandDefinition.cs    | 24 +++++------
 .../Publish/PublishCommandDefinition.cs       | 26 ++++++------
 .../Restore/ImplicitRestoreOptions.cs         |  2 +-
 .../Restore/RestoreCommandDefinition.cs       | 18 ++++-----
 src/Cli/dotnet/Commands/Run/RunCommand.cs     |  2 +-
 .../Commands/Run/RunCommandDefinition.cs      | 12 +++---
 .../Commands/Test/MTP/MSBuildUtility.cs       |  6 +--
 .../MTP/MicrosoftTestingPlatformOptions.cs    |  2 +-
 .../Commands/Test/TestCommandDefinition.cs    | 14 +++----
 .../Commands/Test/VSTest/TestCommand.cs       |  2 +-
 .../Commands/Test/VSTest/VSTestOptions.cs     |  4 +-
 .../Common/Store/StoreCommandDefinition.cs    | 10 ++---
 src/Cli/dotnet/CommonOptions.cs               | 40 ++++++++-----------
 .../MSBuild/GivenDotnetRunInvocation.cs       |  2 +-
 20 files changed, 112 insertions(+), 118 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index 398bde716d78..01c02543d595 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -36,7 +36,7 @@ internal static class BuildCommandDefinition
         Arity = ArgumentArity.Zero
     }.ForwardAs("--property:BuildProjectReferences=false");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
     public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
@@ -44,16 +44,16 @@ internal static class BuildCommandDefinition
 
     public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
+    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.BuildConfigurationOptionDescription);
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.BuildConfigurationOptionDescription);
 
     /// <summary>
     /// Build actually means 'run the default Target' generally in MSBuild
     /// </summary>
-    public static readonly Option<string[]?> TargetOption = CommonOptions.MSBuildTargetOption();
+    public static readonly Option<string[]?> TargetOption = CommonOptions.CreateMSBuildTargetOption();
 
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
@@ -70,13 +70,13 @@ public static Command Create()
         command.Options.Add(FrameworkOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(RuntimeOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
+        command.Options.Add(CommonOptions.CreateVersionSuffixOption());
         command.Options.Add(NoRestoreOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
         command.Options.Add(VerbosityOption);
         command.Options.Add(CommonOptions.DebugOption);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(NoIncrementalOption);
         command.Options.Add(NoDependenciesOption);
         command.Options.Add(NoLogoOption);
@@ -84,12 +84,12 @@ public static Command Create()
         command.Options.Add(NoSelfContainedOption);
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+        command.Options.Add(CommonOptions.CreateGetPropertyOption());
+        command.Options.Add(CommonOptions.CreateGetItemOption());
+        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
+        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
index f04aa32b658b..cf5aa64d6a3a 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
@@ -24,13 +24,13 @@ internal static class CleanCommandDefinition
         HelpName = CliCommandStrings.CleanCmdOutputDir
     }.ForwardAsOutputPath("OutputPath");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
+    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Clean");
+    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Clean");
 
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.normal);
 
@@ -43,19 +43,19 @@ public static Command Create()
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(FrameworkOption);
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription));
         command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
         command.Options.Add(VerbosityOption);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+        command.Options.Add(CommonOptions.CreateGetPropertyOption());
+        command.Options.Add(CommonOptions.CreateGetItemOption());
+        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
+        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
         command.Subcommands.Add(CleanFileBasedAppArtifactsCommandDefinition.Create());
 
         return command;
diff --git a/src/Cli/dotnet/Commands/CommandFactory.cs b/src/Cli/dotnet/Commands/CommandFactory.cs
index 8d857d8383e8..05514de391f4 100644
--- a/src/Cli/dotnet/Commands/CommandFactory.cs
+++ b/src/Cli/dotnet/Commands/CommandFactory.cs
@@ -29,10 +29,10 @@ internal static CommandBase CreateVirtualOrPhysicalCommand(
             var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments([.. forwardedArgs, .. binLogArgs],
             [
                 .. optionsToUseWhenParsingMSBuildFlags,
-                CommonOptions.GetPropertyOption,
-                CommonOptions.GetItemOption,
-                CommonOptions.GetTargetResultOption,
-                CommonOptions.GetResultOutputFileOption,
+                CommonOptions.CreateGetPropertyOption(),
+                CommonOptions.CreateGetItemOption(),
+                CommonOptions.CreateGetTargetResultOption(),
+                CommonOptions.CreateGetResultOutputFileOption(),
             ]);
             msbuildArgs = transformer?.Invoke(msbuildArgs) ?? msbuildArgs;
             return configureVirtualCommand(msbuildArgs, Path.GetFullPath(arg));
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
index 9ddc79a80e47..4a697d9ddf25 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
@@ -20,7 +20,7 @@ public class MSBuildCommand(
         // We set the no-logo option to false here to ensure that by default the logo is shown for this command.
         // This is different from other commands that default to hiding the logo - but this command is meant to mimic
         // the behavior of calling MSBuild directly, which shows the logo by default.
-        CommonOptions.NoLogoOption(false)
+        CommonOptions.CreateNoLogoOption(false)
     ), msbuildPath)
 {
     public static MSBuildCommand FromArgs(string[] args, string? msbuildPath = null)
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
index 43a48acd4459..08599d8f3423 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
@@ -11,7 +11,7 @@ internal static class MSBuildCommandDefinition
     public static readonly string DocsLink = "https://aka.ms/dotnet-msbuild";
 
     public static readonly Argument<string[]> Arguments = new("arguments");
-    public static readonly Option<string[]?> TargetOption = CommonOptions.MSBuildTargetOption();
+    public static readonly Option<string[]?> TargetOption = CommonOptions.CreateMSBuildTargetOption();
 
     public static Command Create()
     {
@@ -21,7 +21,7 @@ public static Command Create()
             DocsLink = DocsLink,
         };
 
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
         command.Options.Add(TargetOption);
 
         return command;
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
index 6134d1c3d516..719a19d57189 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
@@ -42,7 +42,7 @@ private static MSBuildArgs ConcatTelemetryLogger(MSBuildArgs msbuildArgs)
     /// Mostly intended for quick/one-shot usage - most 'core' SDK commands should do more hands-on parsing.
     /// </summary>
     public MSBuildForwardingApp(IEnumerable<string> rawMSBuildArgs, string? msbuildPath = null) : this(
-        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.NoLogoOption()),
+        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption()),
         msbuildPath)
     {
     }
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 63b0dff2aa91..1204708322d0 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -49,13 +49,13 @@ internal static class PackCommandDefinition
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:Serviceable=true");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
     public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
+    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
 
     public static Option<NuGetVersion> VersionOption =
@@ -86,30 +86,30 @@ public static Command Create()
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(NoBuildOption);
         command.Options.Add(IncludeSymbolsOption);
         command.Options.Add(IncludeSourceOption);
         command.Options.Add(ServiceableOption);
         command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
         command.Options.Add(NoRestoreOption);
         command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
+        command.Options.Add(CommonOptions.CreateVersionSuffixOption());
         command.Options.Add(VersionOption);
         command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+        command.Options.Add(CommonOptions.CreateGetPropertyOption());
+        command.Options.Add(CommonOptions.CreateGetItemOption());
+        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
+        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
 
         var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
         implicitOptions.AddTo(command.Options);
 
         command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index 869144b785ed..cb508d74472d 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -38,7 +38,7 @@ internal static class PublishCommandDefinition
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:NoBuild=true");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
     public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
@@ -46,12 +46,12 @@ internal static class PublishCommandDefinition
 
     public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
+    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
+    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
+    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
 
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
 
@@ -67,7 +67,7 @@ public static Command Create()
         implicitOptions.AddTo(command.Options);
         command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(ManifestOption);
         command.Options.Add(NoBuildOption);
         command.Options.Add(SelfContainedOption);
@@ -76,18 +76,18 @@ public static Command Create()
         command.Options.Add(FrameworkOption);
         command.Options.Add(RuntimeOption);
         command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(CommonOptions.CreateVersionSuffixOption());
+        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
         command.Options.Add(NoRestoreOption);
         command.Options.Add(VerbosityOption);
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+        command.Options.Add(CommonOptions.CreateGetPropertyOption());
+        command.Options.Add(CommonOptions.CreateGetItemOption());
+        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
+        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
index 4cc4c15be215..70c000115848 100644
--- a/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
+++ b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
@@ -32,7 +32,7 @@ public ImplicitRestoreOptions(bool showHelp, bool useShortOptions)
             Hidden = !showHelp
         }.ForwardAsSingle(o => $"-property:RestorePackagesPath={CommandDirectoryContext.GetFullPath(o)}");
 
-        CurrentRuntimeOption = CommonOptions.CurrentRuntimeOption(CliCommandStrings.CmdCurrentRuntimeOptionDescription);
+        CurrentRuntimeOption = CommonOptions.CreateUseCurrentRuntimeOption(CliCommandStrings.CmdCurrentRuntimeOptionDescription);
 
         DisableParallelOption = new Option<bool>("--disable-parallel")
         {
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index f03767f75807..9707bbe12ef6 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -18,9 +18,9 @@ internal static class RestoreCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Restore");
+    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
     public static Command Create()
     {
@@ -30,7 +30,7 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
 
         var implicitOptions = new ImplicitRestoreOptions(showHelp: true, useShortOptions: true);
         implicitOptions.AddTo(command.Options);
@@ -38,8 +38,8 @@ public static Command Create()
         command.Options.Add(CreateRuntimeOption(showHelp: true, useShortOptions: true));
         command.Options.Add(CreateNoDependenciesOption(showHelp: true));
         command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(new Option<bool>("--use-lock-file")
         {
             Description = CliCommandStrings.CmdUseLockFileOptionDescription,
@@ -65,10 +65,10 @@ public static Command Create()
 
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+        command.Options.Add(CommonOptions.CreateGetPropertyOption());
+        command.Options.Add(CommonOptions.CreateGetItemOption());
+        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
+        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index 4a0b48ddb7df..aa45281e29d8 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -763,7 +763,7 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             nonBinLogArgs[0] = entryPointFilePath;
         }
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandDefinition.VerbosityOption);
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), RunCommandDefinition.VerbosityOption);
 
         var command = new RunCommand(
             noBuild: noBuild,
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
index 4fe24c881e43..bb5c2df0d273 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -11,11 +11,11 @@ internal static class RunCommandDefinition
 {
     public static readonly string DocsLink = "https://aka.ms/dotnet-run";
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
+    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
+    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
 
     public static readonly Option<string> ProjectOption = new("--project")
     {
@@ -56,7 +56,7 @@ internal static class RunCommandDefinition
 
     public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-    public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
+    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
     public static readonly Option<bool> NoCacheOption = new("--no-cache")
     {
@@ -100,8 +100,8 @@ public static Command Create()
         command.Options.Add(VerbosityOption);
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(CommonOptions.EnvOption);
 
         command.Arguments.Add(ApplicationArguments);
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
index 3b8d5494a143..43150668a9cc 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
@@ -35,7 +35,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
             return (Array.Empty<ParallelizableTestModuleGroupWithSequentialInnerModules>(), isBuiltOrRestored);
         }
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.NoLogoOption());
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption());
         var solutionFile = SolutionFile.Parse(Path.GetFullPath(solutionFilePath));
         var globalProperties = CommonRunHelpers.GetGlobalPropertiesFromArgs(msbuildArgs);
 
@@ -87,7 +87,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
 
         FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. buildOptions.MSBuildArgs], dotnetTestVerb);
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.NoLogoOption());
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption());
 
         using var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs(msbuildArgs), logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
         var evaluationContext = EvaluationContext.Create(EvaluationContext.SharingPolicy.Shared);
@@ -153,7 +153,7 @@ private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOption
             msbuildArgs.Add($"-verbosity:quiet");
         }
 
-        var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, MicrosoftTestingPlatformOptions.MTPTargetOption, TestCommandDefinition.VerbosityOption, CommonOptions.NoLogoOption());
+        var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, MicrosoftTestingPlatformOptions.MTPTargetOption, TestCommandDefinition.VerbosityOption, CommonOptions.CreateNoLogoOption());
 
         int result = new RestoringCommand(parsedMSBuildArgs, buildOptions.HasNoRestore).Execute();
 
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
index fff37275fd84..16100ca88f7a 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
@@ -106,7 +106,7 @@ internal static class MicrosoftTestingPlatformOptions
         Arity = ArgumentArity.Zero
     };
 
-    public static readonly Option<string[]> MTPTargetOption = CommonOptions.RequiredMSBuildTargetOption(CliConstants.MTPTarget);
+    public static readonly Option<string[]> MTPTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget);
 }
 
 internal enum OutputOptions
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index 99282efc76b2..367bb4783cd1 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -32,9 +32,9 @@ private sealed class GlobalJsonTestNode
     public const string Name = "test";
     public static readonly string DocsLink = "https://aka.ms/dotnet-test";
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
+    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
 
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
@@ -106,7 +106,7 @@ public static void ConfigureMicrosoftTestingPlatformCommand(Command command)
         command.Options.Add(ConfigurationOption);
         command.Options.Add(FrameworkOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
         command.Options.Add(VerbosityOption);
         command.Options.Add(CommonOptions.NoRestoreOption);
         command.Options.Add(MicrosoftTestingPlatformOptions.NoBuildOption);
@@ -135,7 +135,7 @@ public static void ConfigureVSTestCommand(Command command)
         command.Options.Add(VSTestOptions.AdapterOption);
         command.Options.Add(VSTestOptions.LoggerOption);
         command.Options.Add(VSTestOptions.OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
         command.Options.Add(VSTestOptions.DiagOption);
         command.Options.Add(VSTestOptions.NoBuildOption);
         command.Options.Add(VSTestOptions.ResultsOption);
@@ -150,14 +150,14 @@ public static void ConfigureVSTestCommand(Command command)
         command.Options.Add(VSTestOptions.NoLogoOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(FrameworkOption);
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
         command.Options.Add(CommonOptions.NoRestoreOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
         command.Options.Add(VerbosityOption);
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.OperatingSystemOption);
         command.Options.Add(CommonOptions.PropertiesOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
         command.Options.Add(VSTestOptions.VsTestTargetOption);
     }
 }
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
index 7ef075d87530..7668b8bc4cc7 100644
--- a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
+++ b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
@@ -241,7 +241,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             CommonOptions.RestorePropertiesOption,
             VSTestOptions.VsTestTargetOption,
             TestCommandDefinition.VerbosityOption,
-            CommonOptions.NoLogoOption())
+            CommonOptions.CreateNoLogoOption())
             .CloneWithNoLogo(true);
 
         TestCommand testCommand = new(
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs b/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
index 05b018a485b1..21c4cd8ef510 100644
--- a/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
+++ b/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
@@ -137,9 +137,9 @@ private static Option<string> CreateBlameHangDumpOption()
         HelpName = CliCommandStrings.HangTimeoutArgumentName
     }.ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangTimeout={o}"]);
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
 
-    public static readonly Option<string[]> VsTestTargetOption = CommonOptions.RequiredMSBuildTargetOption("VSTest");
+    public static readonly Option<string[]> VsTestTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("VSTest");
 
     private static string GetSemiColonEscapedstring(string arg)
     {
diff --git a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
index 8dd53310f4f5..bb8c2324f1de 100644
--- a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
@@ -81,12 +81,12 @@ public static Command Create()
         command.Options.Add(WorkingDirOption);
         command.Options.Add(SkipOptimizationOption);
         command.Options.Add(SkipSymbolsOption);
-        command.Options.Add(CommonOptions.FrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription));
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.CreateFrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription));
+        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription));
         command.Options.Add(CommonOptions.CreateVerbosityOption());
-        command.Options.Add(CommonOptions.CurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(CommonOptions.NoLogoOption(true));
+        command.Options.Add(CommonOptions.CreateUseCurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(CommonOptions.CreateNoLogoOption(true));
 
         return command;
     }
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index a7e5b79143e6..db867126868a 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -66,7 +66,7 @@ internal static class CommonOptions
         return new(dictionary);
     }
 
-    public static Option<string[]?> MSBuildTargetOption(string? defaultTargetName = null, (string key, string value)[]? additionalProperties = null) =>
+    public static Option<string[]?> CreateMSBuildTargetOption(string? defaultTargetName = null, (string key, string value)[]? additionalProperties = null) =>
         new Option<string[]?>("--target", "/target", "-target", "-t", "--t", "/t")
         {
             Description = "Build these targets in this project. Use a semicolon or a comma to separate multiple targets, or specify each target separately.",
@@ -79,7 +79,7 @@ internal static class CommonOptions
         .ForwardAsMany(targets => ForwardTargetsAndAdditionalProperties(targets, additionalProperties))
         .AllowSingleArgPerToken();
 
-    public static Option<string[]> RequiredMSBuildTargetOption(string defaultTargetName, (string key, string value)[]? additionalProperties = null) =>
+    public static Option<string[]> CreateRequiredMSBuildTargetOption(string defaultTargetName, (string key, string value)[]? additionalProperties = null) =>
         new Option<string[]>("--target", "/target", "-target", "-t", "--t", "/t")
         {
             Description = "Build these targets in this project. Use a semicolon or a comma to separate multiple targets, or specify each target separately.",
@@ -107,13 +107,13 @@ public static IEnumerable<string> ForwardTargetsAndAdditionalProperties(string[]
         return argsToReturn;
     }
 
-    public static readonly Option<string[]?> GetPropertyOption = MSBuildMultiOption("getProperty");
+    public static Option<string[]?> CreateGetPropertyOption() => MSBuildMultiOption("getProperty");
 
-    public static readonly Option<string[]?> GetItemOption = MSBuildMultiOption("getItem");
+    public static Option<string[]?> CreateGetItemOption() => MSBuildMultiOption("getItem");
 
-    public static readonly Option<string[]?> GetTargetResultOption = MSBuildMultiOption("getTargetResult");
+    public static Option<string[]?> CreateGetTargetResultOption() => MSBuildMultiOption("getTargetResult");
 
-    public static readonly Option<string[]?> GetResultOutputFileOption = MSBuildMultiOption("getResultOutputFile");
+    public static Option<string[]?> CreateGetResultOutputFileOption() => MSBuildMultiOption("getResultOutputFile");
 
     private static Option<string[]?> MSBuildMultiOption(string name)
         => new Option<string[]?>($"--{name}", $"-{name}", $"/{name}")
@@ -168,7 +168,7 @@ public static Option<VerbosityOptions> CreateHiddenVerbosityOption() =>
         .ForwardAsSingle(o => $"--verbosity:{o}")
         .AggregateRepeatedTokens();
 
-    public static Option<string> FrameworkOption(string description) =>
+    public static Option<string> CreateFrameworkOption(string description) =>
         new Option<string>("--framework", "-f")
         {
             Description = description,
@@ -178,7 +178,7 @@ public static Option<string> FrameworkOption(string description) =>
         .ForwardAsSingle(o => $"--property:TargetFramework={o}")
         .AddCompletions(CliCompletion.TargetFrameworksFromProjectFile);
 
-    public static Option<string> ArtifactsPathOption =
+    public static Option<string> CreateArtifactsPathOption() =>
         new Option<string>(
             //  --artifacts-path is pretty verbose, should we use --artifacts instead (or possibly support both)?
             "--artifacts-path")
@@ -199,7 +199,7 @@ public static IEnumerable<string> RuntimeArgFunc(string rid)
 
     public const string RuntimeOptionName = "--runtime";
 
-    public static Option<string> RuntimeOption(string description) =>
+    public static Option<string> CreateRuntimeOption(string description) =>
         new Option<string>(RuntimeOptionName, "-r")
         {
             HelpName = RuntimeArgName,
@@ -208,22 +208,14 @@ public static Option<string> RuntimeOption(string description) =>
         }.ForwardAsMany(RuntimeArgFunc!)
         .AddCompletions(CliCompletion.RunTimesFromProjectFile);
 
-    public static Option<string> LongFormRuntimeOption =
-        new Option<string>(RuntimeOptionName)
-        {
-            HelpName = RuntimeArgName,
-            IsDynamic = true,
-        }.ForwardAsMany(RuntimeArgFunc!)
-        .AddCompletions(CliCompletion.RunTimesFromProjectFile);
-
-    public static Option<bool> CurrentRuntimeOption(string description) =>
+    public static Option<bool> CreateUseCurrentRuntimeOption(string description) =>
         new Option<bool>("--use-current-runtime", "--ucr")
         {
             Description = description,
             Arity = ArgumentArity.Zero
         }.ForwardAs("--property:UseCurrentRuntimeIdentifier=True");
 
-    public static Option<string?> ConfigurationOption(string description) =>
+    public static Option<string?> CreateConfigurationOption(string description) =>
         new Option<string?>("--configuration", "-c")
         {
             Description = description,
@@ -232,7 +224,7 @@ public static Option<bool> CurrentRuntimeOption(string description) =>
         }.ForwardAsSingle(o => $"--property:Configuration={o}")
         .AddCompletions(CliCompletion.ConfigurationsFromProjectFileOrDefaults);
 
-    public static Option<string> VersionSuffixOption =
+    public static Option<string> CreateVersionSuffixOption() =>
         new Option<string>("--version-suffix")
         {
             Description = CliStrings.CmdVersionSuffixDescription,
@@ -287,9 +279,11 @@ public static Option<bool> CreateInteractiveOption(bool acceptArgument = false,
             Hidden = hidden,
         };
 
-    public static Option<bool> InteractiveMsBuildForwardOption = CreateInteractiveOption(acceptArgument: true).ForwardAsSingle(b => $"--property:NuGetInteractive={(b ? "true" : "false")}");
+    public static Option<bool> CreateInteractiveMsBuildForwardOption()
+        => CreateInteractiveOption(acceptArgument: true)
+           .ForwardAsSingle(b => $"--property:NuGetInteractive={(b ? "true" : "false")}");
 
-    public static Option<bool> DisableBuildServersOption =
+    public static Option<bool> CreateDisableBuildServersOption() =>
         new Option<bool>("--disable-build-servers")
         {
             Description = CliStrings.DisableBuildServersOptionDescription,
@@ -410,7 +404,7 @@ private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(Arg
     /// </list>
     /// Finally, if neither the option nor the environment variable is set, the option will default to the provided <paramref name="defaultValue"/>.
     /// </summary>
-    public static Option<bool> NoLogoOption(bool defaultValue = true, string forwardAs = "--nologo", string? description = null)
+    public static Option<bool> CreateNoLogoOption(bool defaultValue = true, string forwardAs = "--nologo", string? description = null)
     {
         return new Option<bool>("--no-logo", "--nologo", "-nologo", "/nologo")
         {
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
index 8ddf0e1d9ea5..1334303ac67b 100644
--- a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
+++ b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
@@ -43,7 +43,7 @@ public void MsbuildInvocationIsCorrect(string[] args, string[] expectedArgs)
                     var command = RunCommand.FromArgs(args);
                     command.MSBuildArgs
                         .Should()
-                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments([.. ConstantRestoreArgs, .. expectedArgs, NuGetDisabledProperty ], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandDefinition.VerbosityOption, CommonOptions.NoLogoOption()));
+                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments([.. ConstantRestoreArgs, .. expectedArgs, NuGetDisabledProperty ], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), RunCommandDefinition.VerbosityOption, CommonOptions.CreateNoLogoOption()));
                 });
             }
             finally

From 06141232be78d51237c99d9c5e399bd7cc7fda0f Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 2 Jan 2026 21:05:33 -0600
Subject: [PATCH 05/20] Add fields

---
 .../Commands/Build/BuildCommandDefinition.cs  | 39 ++++++---
 .../Commands/Clean/CleanCommandDefinition.cs  | 25 ++++--
 .../MSBuild/MSBuildCommandDefinition.cs       |  3 +-
 .../Commands/Pack/PackCommandDefinition.cs    | 36 +++++---
 .../Publish/PublishCommandDefinition.cs       | 39 ++++++---
 .../Restore/RestoreCommandDefinition.cs       | 84 +++++++++++--------
 .../Common/Store/StoreCommandDefinition.cs    | 19 +++--
 .../Restore/RestoreParserTests.cs             |  2 +-
 8 files changed, 159 insertions(+), 88 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index 01c02543d595..987fefbec459 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -18,6 +18,8 @@ internal static class BuildCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
+    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+
     public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.BuildOutputOptionDescription,
@@ -57,6 +59,18 @@ internal static class BuildCommandDefinition
 
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
+    public static readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
+    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public static readonly Option<bool> DebugOption = CommonOptions.DebugOption;
+    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+    public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+
     public static Command Create()
     {
         Command command = new("build", CliCommandStrings.BuildAppFullName)
@@ -65,31 +79,30 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
-        implicitOptions.AddTo(command.Options);
+        ImplicitRestoreOptions.AddTo(command.Options);
         command.Options.Add(FrameworkOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(RuntimeOption);
-        command.Options.Add(CommonOptions.CreateVersionSuffixOption());
+        command.Options.Add(VersionSuffixOption);
         command.Options.Add(NoRestoreOption);
-        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+        command.Options.Add(InteractiveOption);
         command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.DebugOption);
+        command.Options.Add(DebugOption);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
+        command.Options.Add(ArtifactsPathOption);
         command.Options.Add(NoIncrementalOption);
         command.Options.Add(NoDependenciesOption);
         command.Options.Add(NoLogoOption);
         command.Options.Add(SelfContainedOption);
         command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(ArchitectureOption);
+        command.Options.Add(OperatingSystemOption);
+        command.Options.Add(DisableBuildServersOption);
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.CreateGetPropertyOption());
-        command.Options.Add(CommonOptions.CreateGetItemOption());
-        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
-        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
+        command.Options.Add(GetPropertyOption);
+        command.Options.Add(GetItemOption);
+        command.Options.Add(GetTargetResultOption);
+        command.Options.Add(GetResultOutputFileOption);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
index cf5aa64d6a3a..c5a6fef2eff3 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
@@ -34,6 +34,15 @@ internal static class CleanCommandDefinition
 
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.normal);
 
+    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription);
+    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+
     public static Command Create()
     {
         Command command = new("clean", CliCommandStrings.CleanAppFullName)
@@ -43,19 +52,19 @@ public static Command Create()
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(FrameworkOption);
-        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription));
+        command.Options.Add(RuntimeOption);
         command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+        command.Options.Add(InteractiveOption);
         command.Options.Add(VerbosityOption);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
+        command.Options.Add(ArtifactsPathOption);
         command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(DisableBuildServersOption);
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.CreateGetPropertyOption());
-        command.Options.Add(CommonOptions.CreateGetItemOption());
-        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
-        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
+        command.Options.Add(GetPropertyOption);
+        command.Options.Add(GetItemOption);
+        command.Options.Add(GetTargetResultOption);
+        command.Options.Add(GetResultOutputFileOption);
         command.Subcommands.Add(CleanFileBasedAppArtifactsCommandDefinition.Create());
 
         return command;
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
index 08599d8f3423..350e72607a75 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
@@ -12,6 +12,7 @@ internal static class MSBuildCommandDefinition
 
     public static readonly Argument<string[]> Arguments = new("arguments");
     public static readonly Option<string[]?> TargetOption = CommonOptions.CreateMSBuildTargetOption();
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
 
     public static Command Create()
     {
@@ -21,7 +22,7 @@ public static Command Create()
             DocsLink = DocsLink,
         };
 
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(DisableBuildServersOption);
         command.Options.Add(TargetOption);
 
         return command;
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 1204708322d0..86dace1116f5 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -19,6 +19,8 @@ internal static class PackCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
+    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+
     public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.PackCmdOutputDirDescription,
@@ -58,6 +60,17 @@ internal static class PackCommandDefinition
     public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
 
+    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public static readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+    public static readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
+    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+
     public static Option<NuGetVersion> VersionOption =
         new Option<NuGetVersion>("--version")
         {
@@ -86,30 +99,29 @@ public static Command Create()
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
+        command.Options.Add(ArtifactsPathOption);
         command.Options.Add(NoBuildOption);
         command.Options.Add(IncludeSymbolsOption);
         command.Options.Add(IncludeSourceOption);
         command.Options.Add(ServiceableOption);
         command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+        command.Options.Add(InteractiveOption);
         command.Options.Add(NoRestoreOption);
         command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.CreateVersionSuffixOption());
+        command.Options.Add(VersionSuffixOption);
         command.Options.Add(VersionOption);
         command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(DisableBuildServersOption);
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.CreateGetPropertyOption());
-        command.Options.Add(CommonOptions.CreateGetItemOption());
-        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
-        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
+        command.Options.Add(GetPropertyOption);
+        command.Options.Add(GetItemOption);
+        command.Options.Add(GetTargetResultOption);
+        command.Options.Add(GetResultOutputFileOption);
 
-        var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
-        implicitOptions.AddTo(command.Options);
+        ImplicitRestoreOptions.AddTo(command.Options);
 
-        command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
-        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
+        command.Options.Add(NoDependenciesOption);
+        command.Options.Add(RuntimeOption);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index cb508d74472d..5b429519d66f 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -19,6 +19,8 @@ internal static class PublishCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
+    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+
     public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.PublishOutputOptionDescription,
@@ -55,6 +57,18 @@ internal static class PublishCommandDefinition
 
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
 
+    public static readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
+    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public static readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
+    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+    public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+
     public static Command Create()
     {
         var command = new Command("publish", CliCommandStrings.PublishAppDescription)
@@ -63,11 +77,10 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        var implicitOptions = new ImplicitRestoreOptions(showHelp: false, useShortOptions: false);
-        implicitOptions.AddTo(command.Options);
-        command.Options.Add(RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false));
+        ImplicitRestoreOptions.AddTo(command.Options);
+        command.Options.Add(NoDependenciesOption);
         command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
+        command.Options.Add(ArtifactsPathOption);
         command.Options.Add(ManifestOption);
         command.Options.Add(NoBuildOption);
         command.Options.Add(SelfContainedOption);
@@ -76,18 +89,18 @@ public static Command Create()
         command.Options.Add(FrameworkOption);
         command.Options.Add(RuntimeOption);
         command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.CreateVersionSuffixOption());
-        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+        command.Options.Add(VersionSuffixOption);
+        command.Options.Add(InteractiveOption);
         command.Options.Add(NoRestoreOption);
         command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(ArchitectureOption);
+        command.Options.Add(OperatingSystemOption);
+        command.Options.Add(DisableBuildServersOption);
         command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.CreateGetPropertyOption());
-        command.Options.Add(CommonOptions.CreateGetItemOption());
-        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
-        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
+        command.Options.Add(GetPropertyOption);
+        command.Options.Add(GetItemOption);
+        command.Options.Add(GetTargetResultOption);
+        command.Options.Add(GetResultOutputFileOption);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index 9707bbe12ef6..df6fe15a3d8a 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -4,7 +4,6 @@
 using System.CommandLine;
 using System.CommandLine.StaticCompletions;
 using Microsoft.DotNet.Cli.CommandLine;
-using NuGet.Packaging;
 
 namespace Microsoft.DotNet.Cli.Commands.Restore;
 
@@ -18,10 +17,44 @@ internal static class RestoreCommandDefinition
         Arity = ArgumentArity.ZeroOrMore
     };
 
+    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: true, useShortOptions: true);
+
     public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
     public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
     public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public static readonly Option<IEnumerable<string>> RuntimeOption = CreateRuntimeOption(showHelp: true, useShortOptions: true);
+    public static readonly Option<bool> NoDependenciesOption = CreateNoDependenciesOption(showHelp: true);
+    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public static readonly Option<bool> UseLockFileOption = new Option<bool>("--use-lock-file")
+    {
+        Description = CliCommandStrings.CmdUseLockFileOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:RestorePackagesWithLockFile=true");
+    public static readonly Option<bool> LockedModeOption = new Option<bool>("--locked-mode")
+    {
+        Description = CliCommandStrings.CmdLockedModeOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:RestoreLockedMode=true");
+    public static readonly Option<string> LockFilePathOption = new Option<string>("--lock-file-path")
+    {
+        Description = CliCommandStrings.CmdLockFilePathOptionDescription,
+        HelpName = CliCommandStrings.CmdLockFilePathOption
+    }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}");
+    public static readonly Option<bool> ForceEvaluateOption = new Option<bool>("--force-evaluate")
+    {
+        Description = CliCommandStrings.CmdReevaluateOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:RestoreForceEvaluate=true");
+    public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+    public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+
     public static Command Create()
     {
         var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
@@ -30,45 +63,28 @@ public static Command Create()
         };
 
         command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
+        command.Options.Add(DisableBuildServersOption);
 
-        var implicitOptions = new ImplicitRestoreOptions(showHelp: true, useShortOptions: true);
-        implicitOptions.AddTo(command.Options);
+        ImplicitRestoreOptions.AddTo(command.Options);
 
-        command.Options.Add(CreateRuntimeOption(showHelp: true, useShortOptions: true));
-        command.Options.Add(CreateNoDependenciesOption(showHelp: true));
+        command.Options.Add(RuntimeOption);
+        command.Options.Add(NoDependenciesOption);
         command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
-        command.Options.Add(new Option<bool>("--use-lock-file")
-        {
-            Description = CliCommandStrings.CmdUseLockFileOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestorePackagesWithLockFile=true"));
-        command.Options.Add(new Option<bool>("--locked-mode")
-        {
-            Description = CliCommandStrings.CmdLockedModeOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreLockedMode=true"));
-        command.Options.Add(new Option<string>("--lock-file-path")
-        {
-            Description = CliCommandStrings.CmdLockFilePathOptionDescription,
-            HelpName = CliCommandStrings.CmdLockFilePathOption
-        }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}"));
-        command.Options.Add(new Option<bool>("--force-evaluate")
-        {
-            Description = CliCommandStrings.CmdReevaluateOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreForceEvaluate=true"));
+        command.Options.Add(InteractiveOption);
+        command.Options.Add(ArtifactsPathOption);
+        command.Options.Add(UseLockFileOption);
+        command.Options.Add(LockedModeOption);
+        command.Options.Add(LockFilePathOption);
+        command.Options.Add(ForceEvaluateOption);
         command.Options.Add(TargetOption);
         command.Options.Add(NoLogoOption);
 
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.CreateGetPropertyOption());
-        command.Options.Add(CommonOptions.CreateGetItemOption());
-        command.Options.Add(CommonOptions.CreateGetTargetResultOption());
-        command.Options.Add(CommonOptions.CreateGetResultOutputFileOption());
+        command.Options.Add(ArchitectureOption);
+        command.Options.Add(OperatingSystemOption);
+        command.Options.Add(GetPropertyOption);
+        command.Options.Add(GetItemOption);
+        command.Options.Add(GetTargetResultOption);
+        command.Options.Add(GetResultOutputFileOption);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
index bb8c2324f1de..71e9b5d7bdd4 100644
--- a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
@@ -67,6 +67,13 @@ internal static class StoreCommandDefinition
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:CreateProfilingSymbols=false");
 
+    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription);
+    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription);
+    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+    public static readonly Option<bool> UseCurrentRuntimeOption = CommonOptions.CreateUseCurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription);
+    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(true);
+
     public static Command Create()
     {
         Command command = new("store", CliCommandStrings.StoreAppDescription)
@@ -81,12 +88,12 @@ public static Command Create()
         command.Options.Add(WorkingDirOption);
         command.Options.Add(SkipOptimizationOption);
         command.Options.Add(SkipSymbolsOption);
-        command.Options.Add(CommonOptions.CreateFrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription));
-        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.CreateVerbosityOption());
-        command.Options.Add(CommonOptions.CreateUseCurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
-        command.Options.Add(CommonOptions.CreateNoLogoOption(true));
+        command.Options.Add(FrameworkOption);
+        command.Options.Add(RuntimeOption);
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(UseCurrentRuntimeOption);
+        command.Options.Add(DisableBuildServersOption);
+        command.Options.Add(NoLogoOption);
 
         return command;
     }
diff --git a/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
index ae8c54776d9f..0398f677165f 100644
--- a/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
@@ -41,7 +41,7 @@ public void RestoreDistinguishesRepeatSourceArgsFromCommandArgs()
 
             restore.GetValue(RestoreCommandDefinition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@"D:\OSS\corefx\external\runtime\runtime.depproj");
 
-            restore.GetValue(RestoreCommandDefinition.SourceOption)
+            restore.GetValue(RestoreCommandDefinition.ImplicitRestoreOptions.SourceOption)
                 .Should()
                 .BeEquivalentTo(
                     "https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json",

From 2daaacfc901264e6f5d711e8e90c646c26aed7ce Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Mon, 5 Jan 2026 12:24:30 -0800
Subject: [PATCH 06/20] Pack command definition

---
 .../Commands/Pack/PackCommandDefinition.cs    | 66 +++++++++----------
 .../dotnet/Commands/Pack/PackCommandParser.cs |  5 +-
 2 files changed, 34 insertions(+), 37 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 86dace1116f5..3f39a1daf5ca 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -9,9 +9,9 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
-internal static class PackCommandDefinition
+internal sealed class PackCommandDefinition : Command
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-pack";
+    private const string Link = "https://aka.ms/dotnet-pack";
 
     public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
@@ -90,39 +90,35 @@ internal static class PackCommandDefinition
             }
         }.ForwardAsSingle(o => $"--property:PackageVersion={o}");
 
-    public static Command Create()
+    public PackCommandDefinition()
+        : base("pack", CliCommandStrings.PackAppFullName)
     {
-        var command = new Command("pack", CliCommandStrings.PackAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(OutputOption);
-        command.Options.Add(ArtifactsPathOption);
-        command.Options.Add(NoBuildOption);
-        command.Options.Add(IncludeSymbolsOption);
-        command.Options.Add(IncludeSourceOption);
-        command.Options.Add(ServiceableOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(VersionSuffixOption);
-        command.Options.Add(VersionOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(GetPropertyOption);
-        command.Options.Add(GetItemOption);
-        command.Options.Add(GetTargetResultOption);
-        command.Options.Add(GetResultOutputFileOption);
-
-        ImplicitRestoreOptions.AddTo(command.Options);
-
-        command.Options.Add(NoDependenciesOption);
-        command.Options.Add(RuntimeOption);
-
-        return command;
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        Options.Add(OutputOption);
+        Options.Add(ArtifactsPathOption);
+        Options.Add(NoBuildOption);
+        Options.Add(IncludeSymbolsOption);
+        Options.Add(IncludeSourceOption);
+        Options.Add(ServiceableOption);
+        Options.Add(NoLogoOption);
+        Options.Add(InteractiveOption);
+        Options.Add(NoRestoreOption);
+        Options.Add(VerbosityOption);
+        Options.Add(VersionSuffixOption);
+        Options.Add(VersionOption);
+        Options.Add(ConfigurationOption);
+        Options.Add(DisableBuildServersOption);
+        Options.Add(TargetOption);
+        Options.Add(GetPropertyOption);
+        Options.Add(GetItemOption);
+        Options.Add(GetTargetResultOption);
+        Options.Add(GetResultOutputFileOption);
+
+        ImplicitRestoreOptions.AddTo(Options);
+
+        Options.Add(NoDependenciesOption);
+        Options.Add(RuntimeOption);
     }
 }
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
index 577d3d2c9bb4..1c892fd2b95e 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
@@ -7,15 +7,16 @@ namespace Microsoft.DotNet.Cli.Commands.Pack;
 
 internal static class PackCommandParser
 {
-    private static readonly Command Command = SetAction(PackCommandDefinition.Create());
+    private static readonly PackCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command SetAction(Command command)
+    private static PackCommandDefinition CreateCommand()
     {
+        var command = new PackCommandDefinition();
         command.SetAction(PackCommand.Run);
         return command;
     }

From 1ff71e7642600ca8af8f8ebd3b1f9140c2b748a5 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Mon, 5 Jan 2026 13:21:55 -0800
Subject: [PATCH 07/20] Test command definitions

---
 ...icrosoftTestingPlatformTestCommand.Help.cs |   3 +-
 .../MicrosoftTestingPlatformTestCommand.cs    |  11 +-
 .../Commands/Test/TestCommandDefinition.cs    | 195 +++++++++---------
 .../dotnet/Commands/Test/TestCommandParser.cs |  37 ++--
 4 files changed, 124 insertions(+), 122 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.Help.cs b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.Help.cs
index 23c1b63ab818..ca5c4b76a06a 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.Help.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.Help.cs
@@ -4,11 +4,12 @@
 using System.Collections.Concurrent;
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Test.IPC.Models;
+using Microsoft.TemplateEngine.Cli.Commands;
 using Microsoft.TemplateEngine.Cli.Help;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
-internal partial class MicrosoftTestingPlatformTestCommand
+internal partial class MicrosoftTestingPlatformTestCommand : ICustomHelp
 {
     private readonly ConcurrentDictionary<string, CommandLineOptionMessage> _commandLineOptionNameToModuleNames = [];
     private readonly ConcurrentDictionary<bool, List<(string, string[])>> _moduleNamesToCommandLineOptions = [];
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs
index d84264e6c49e..b3e24c51a227 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs
@@ -7,21 +7,14 @@
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Test.Terminal;
 using Microsoft.DotNet.Cli.Extensions;
-using Microsoft.TemplateEngine.Cli.Commands;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
-internal partial class MicrosoftTestingPlatformTestCommand : Command, ICustomHelp
+internal partial class MicrosoftTestingPlatformTestCommand
 {
     private TerminalTestReporter? _output;
 
-    public MicrosoftTestingPlatformTestCommand(string name, string? description = null) : base(name, description)
-    {
-        TreatUnmatchedTokensAsErrors = false;
-        this.DocsLink = "https://aka.ms/dotnet-test";
-    }
-
-    public int Run(ParseResult parseResult, bool isHelp = false)
+    public int Run(ParseResult parseResult, bool isHelp)
     {
         int? exitCode = null;
         try
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index 367bb4783cd1..f9873d19084c 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -5,32 +5,15 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.TemplateEngine.Cli.Commands;
+using Microsoft.TemplateEngine.Cli.Help;
 using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
-internal static class TestCommandDefinition
+internal abstract class TestCommandDefinition : Command
 {
-    public enum TestRunner
-    {
-        VSTest,
-        MicrosoftTestingPlatform
-    }
-
-    private sealed class GlobalJsonModel
-    {
-        [JsonPropertyName("test")]
-        public GlobalJsonTestNode Test { get; set; } = null!;
-    }
-
-    private sealed class GlobalJsonTestNode
-    {
-        [JsonPropertyName("runner")]
-        public string RunnerName { get; set; } = null!;
-    }
-
-    public const string Name = "test";
-    public static readonly string DocsLink = "https://aka.ms/dotnet-test";
+    private const string Link = "https://aka.ms/dotnet-test";
 
     public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
 
@@ -38,12 +21,19 @@ private sealed class GlobalJsonTestNode
 
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public static TestRunner GetTestRunner()
+    public TestCommandDefinition(string description)
+        : base("test", description)
+    {
+        this.DocsLink = Link;
+        TreatUnmatchedTokensAsErrors = false;
+    }
+
+    public static TestCommandDefinition Create()
     {
         string? globalJsonPath = GetGlobalJsonPath(Environment.CurrentDirectory);
         if (!File.Exists(globalJsonPath))
         {
-            return TestRunner.VSTest;
+            return new VSTest();
         }
 
         string jsonText = File.ReadAllText(globalJsonPath);
@@ -61,12 +51,12 @@ public static TestRunner GetTestRunner()
 
         if (name is null || name.Equals(CliConstants.VSTest, StringComparison.OrdinalIgnoreCase))
         {
-            return TestRunner.VSTest;
+            return new VSTest();
         }
 
         if (name.Equals(CliConstants.MicrosoftTestingPlatform, StringComparison.OrdinalIgnoreCase))
         {
-            return TestRunner.MicrosoftTestingPlatform;
+            return new MicrosoftTestingPlatform();
         }
 
         throw new InvalidOperationException(string.Format(CliCommandStrings.CmdUnsupportedTestRunnerDescription, name));
@@ -85,79 +75,100 @@ public static TestRunner GetTestRunner()
 
             directory = Path.GetDirectoryName(directory);
         }
+
         return null;
     }
 
-    public static void ConfigureMicrosoftTestingPlatformCommand(Command command)
+    private sealed class GlobalJsonModel
+    {
+        [JsonPropertyName("test")]
+        public GlobalJsonTestNode Test { get; set; } = null!;
+    }
+
+    private sealed class GlobalJsonTestNode
+    {
+        [JsonPropertyName("runner")]
+        public string RunnerName { get; set; } = null!;
+    }
+
+    public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHelp
     {
-        command.Description = CliCommandStrings.DotnetTestCommandMTPDescription;
-        command.Options.Add(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.SolutionOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.TestModulesFilterOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.ResultsDirectoryOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.ConfigFileOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.EnvOption);
-        command.Options.Add(CommonOptions.PropertiesOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.NoRestoreOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.NoBuildOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.NoAnsiOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.NoProgressOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.OutputOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.ListTestsOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.NoLaunchProfileOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption);
-        command.Options.Add(MicrosoftTestingPlatformOptions.MTPTargetOption);
+        public ICustomHelp? CustomHelpLayoutProvider { get; set; }
+
+        public MicrosoftTestingPlatform()
+            : base(CliCommandStrings.DotnetTestCommandMTPDescription)
+        {
+            Options.Add(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption);
+            Options.Add(MicrosoftTestingPlatformOptions.SolutionOption);
+            Options.Add(MicrosoftTestingPlatformOptions.TestModulesFilterOption);
+            Options.Add(MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption);
+            Options.Add(MicrosoftTestingPlatformOptions.ResultsDirectoryOption);
+            Options.Add(MicrosoftTestingPlatformOptions.ConfigFileOption);
+            Options.Add(MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption);
+            Options.Add(MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption);
+            Options.Add(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption);
+            Options.Add(CommonOptions.ArchitectureOption);
+            Options.Add(CommonOptions.EnvOption);
+            Options.Add(CommonOptions.PropertiesOption);
+            Options.Add(ConfigurationOption);
+            Options.Add(FrameworkOption);
+            Options.Add(CommonOptions.OperatingSystemOption);
+            Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
+            Options.Add(VerbosityOption);
+            Options.Add(CommonOptions.NoRestoreOption);
+            Options.Add(MicrosoftTestingPlatformOptions.NoBuildOption);
+            Options.Add(MicrosoftTestingPlatformOptions.NoAnsiOption);
+            Options.Add(MicrosoftTestingPlatformOptions.NoProgressOption);
+            Options.Add(MicrosoftTestingPlatformOptions.OutputOption);
+            Options.Add(MicrosoftTestingPlatformOptions.ListTestsOption);
+            Options.Add(MicrosoftTestingPlatformOptions.NoLaunchProfileOption);
+            Options.Add(MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption);
+            Options.Add(MicrosoftTestingPlatformOptions.MTPTargetOption);
+        }
+
+        public IEnumerable<Action<HelpContext>> CustomHelpLayout()
+            => CustomHelpLayoutProvider?.CustomHelpLayout() ?? [];
     }
 
-    public static void ConfigureVSTestCommand(Command command)
+    public sealed class VSTest : TestCommandDefinition
     {
-        command.Description = CliCommandStrings.DotnetTestCommandVSTestDescription;
-        command.TreatUnmatchedTokensAsErrors = false;
-        command.DocsLink = DocsLink;
-
-        // We are on purpose not capturing the solution, project or directory here. We want to pass it to the
-        // MSBuild command so we are letting it flow.
-
-        command.Options.Add(VSTestOptions.SettingsOption);
-        command.Options.Add(VSTestOptions.ListTestsOption);
-        command.Options.Add(CommonOptions.TestEnvOption);
-        command.Options.Add(VSTestOptions.FilterOption);
-        command.Options.Add(VSTestOptions.AdapterOption);
-        command.Options.Add(VSTestOptions.LoggerOption);
-        command.Options.Add(VSTestOptions.OutputOption);
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
-        command.Options.Add(VSTestOptions.DiagOption);
-        command.Options.Add(VSTestOptions.NoBuildOption);
-        command.Options.Add(VSTestOptions.ResultsOption);
-        command.Options.Add(VSTestOptions.CollectOption);
-        command.Options.Add(VSTestOptions.BlameOption);
-        command.Options.Add(VSTestOptions.BlameCrashOption);
-        command.Options.Add(VSTestOptions.BlameCrashDumpOption);
-        command.Options.Add(VSTestOptions.BlameCrashAlwaysOption);
-        command.Options.Add(VSTestOptions.BlameHangOption);
-        command.Options.Add(VSTestOptions.BlameHangDumpOption);
-        command.Options.Add(VSTestOptions.BlameHangTimeoutOption);
-        command.Options.Add(VSTestOptions.NoLogoOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.NoRestoreOption);
-        command.Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.PropertiesOption);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
-        command.Options.Add(VSTestOptions.VsTestTargetOption);
+        public VSTest()
+            : base(CliCommandStrings.DotnetTestCommandVSTestDescription)
+        {
+            // We are on purpose not capturing the solution, project or directory here. We want to pass it to the
+            // MSBuild command so we are letting it flow.
+
+            Options.Add(VSTestOptions.SettingsOption);
+            Options.Add(VSTestOptions.ListTestsOption);
+            Options.Add(CommonOptions.TestEnvOption);
+            Options.Add(VSTestOptions.FilterOption);
+            Options.Add(VSTestOptions.AdapterOption);
+            Options.Add(VSTestOptions.LoggerOption);
+            Options.Add(VSTestOptions.OutputOption);
+            Options.Add(CommonOptions.CreateArtifactsPathOption());
+            Options.Add(VSTestOptions.DiagOption);
+            Options.Add(VSTestOptions.NoBuildOption);
+            Options.Add(VSTestOptions.ResultsOption);
+            Options.Add(VSTestOptions.CollectOption);
+            Options.Add(VSTestOptions.BlameOption);
+            Options.Add(VSTestOptions.BlameCrashOption);
+            Options.Add(VSTestOptions.BlameCrashDumpOption);
+            Options.Add(VSTestOptions.BlameCrashAlwaysOption);
+            Options.Add(VSTestOptions.BlameHangOption);
+            Options.Add(VSTestOptions.BlameHangDumpOption);
+            Options.Add(VSTestOptions.BlameHangTimeoutOption);
+            Options.Add(VSTestOptions.NoLogoOption);
+            Options.Add(ConfigurationOption);
+            Options.Add(FrameworkOption);
+            Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
+            Options.Add(CommonOptions.NoRestoreOption);
+            Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+            Options.Add(VerbosityOption);
+            Options.Add(CommonOptions.ArchitectureOption);
+            Options.Add(CommonOptions.OperatingSystemOption);
+            Options.Add(CommonOptions.PropertiesOption);
+            Options.Add(CommonOptions.CreateDisableBuildServersOption());
+            Options.Add(VSTestOptions.VsTestTargetOption);
+        }
     }
 }
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
index 57300d5ee0ff..19a435e0007c 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
@@ -7,36 +7,33 @@ namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal static class TestCommandParser
 {
-    private static readonly Command Command = CreateCommand();
+    private static readonly TestCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command CreateCommand()
+    private static TestCommandDefinition CreateCommand()
     {
-        return TestCommandDefinition.GetTestRunner() switch
+        var command = TestCommandDefinition.Create();
+
+        switch (command)
         {
-            TestCommandDefinition.TestRunner.VSTest => CreateVSTestCommand(),
-            TestCommandDefinition.TestRunner.MicrosoftTestingPlatform => CreateTestingPlatformCommand(),
-            _ => throw new NotSupportedException(),
-        };
-    }
+            case TestCommandDefinition.VSTest vs:
+                vs.SetAction(TestCommand.Run);
+                break;
 
-    private static Command CreateTestingPlatformCommand()
-    {
-        var command = new MicrosoftTestingPlatformTestCommand(TestCommandDefinition.Name);
-        TestCommandDefinition.ConfigureMicrosoftTestingPlatformCommand(command);
-        command.SetAction(parseResult => command.Run(parseResult));
-        return command;
-    }
+            case TestCommandDefinition.MicrosoftTestingPlatform mtp:
+                var impl = new MicrosoftTestingPlatformTestCommand();
+                mtp.SetAction(parseResult => impl.Run(parseResult, isHelp: false));
+                mtp.CustomHelpLayoutProvider = impl;
+                break;
+
+            default:
+                throw new NotSupportedException();
+        };
 
-    private static Command CreateVSTestCommand()
-    {
-        var command = new Command(TestCommandDefinition.Name);
-        TestCommandDefinition.ConfigureVSTestCommand(command);
-        command.SetAction(TestCommand.Run);
         return command;
     }
 }

From 408a1f9436f9be784d064803c0b4d0ee2c695fe4 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Mon, 5 Jan 2026 13:32:12 -0800
Subject: [PATCH 08/20] Test command def fields

---
 .../Commands/Test/TestCommandDefinition.cs    | 156 ++++++++++++------
 1 file changed, 105 insertions(+), 51 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index f9873d19084c..61dcc40150af 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -1,6 +1,7 @@
 // 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.ObjectModel;
 using System.CommandLine;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -93,37 +94,61 @@ private sealed class GlobalJsonTestNode
 
     public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHelp
     {
+        public static readonly Option<string> ProjectOrSolutionOption = MicrosoftTestingPlatformOptions.ProjectOrSolutionOption;
+        public static readonly Option<string> SolutionOption = MicrosoftTestingPlatformOptions.SolutionOption;
+        public static readonly Option<string> TestModulesFilterOption = MicrosoftTestingPlatformOptions.TestModulesFilterOption;
+        public static readonly Option<string> TestModulesRootDirectoryOption = MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption;
+        public static readonly Option<string> ResultsDirectoryOption = MicrosoftTestingPlatformOptions.ResultsDirectoryOption;
+        public static readonly Option<string> ConfigFileOption = MicrosoftTestingPlatformOptions.ConfigFileOption;
+        public static readonly Option<string> DiagnosticOutputDirectoryOption = MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption;
+        public static readonly Option<int> MaxParallelTestModulesOption = MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption;
+        public static readonly Option<int> MinimumExpectedTestsOption = MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption;
+        public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+        public static readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
+        public static readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+        public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+        public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> NoBuildOption = MicrosoftTestingPlatformOptions.NoBuildOption;
+        public static readonly Option<bool> NoAnsiOption = MicrosoftTestingPlatformOptions.NoAnsiOption;
+        public static readonly Option<bool> NoProgressOption = MicrosoftTestingPlatformOptions.NoProgressOption;
+        public static readonly Option<OutputOptions> OutputOption = MicrosoftTestingPlatformOptions.OutputOption;
+        public static readonly Option<string> ListTestsOption = MicrosoftTestingPlatformOptions.ListTestsOption;
+        public static readonly Option<bool> NoLaunchProfileOption = MicrosoftTestingPlatformOptions.NoLaunchProfileOption;
+        public static readonly Option<bool> NoLaunchProfileArgumentsOption = MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption;
+        public static readonly Option<string[]> MTPTargetOption = MicrosoftTestingPlatformOptions.MTPTargetOption;
+
         public ICustomHelp? CustomHelpLayoutProvider { get; set; }
 
         public MicrosoftTestingPlatform()
             : base(CliCommandStrings.DotnetTestCommandMTPDescription)
         {
-            Options.Add(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption);
-            Options.Add(MicrosoftTestingPlatformOptions.SolutionOption);
-            Options.Add(MicrosoftTestingPlatformOptions.TestModulesFilterOption);
-            Options.Add(MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption);
-            Options.Add(MicrosoftTestingPlatformOptions.ResultsDirectoryOption);
-            Options.Add(MicrosoftTestingPlatformOptions.ConfigFileOption);
-            Options.Add(MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption);
-            Options.Add(MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption);
-            Options.Add(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption);
-            Options.Add(CommonOptions.ArchitectureOption);
-            Options.Add(CommonOptions.EnvOption);
-            Options.Add(CommonOptions.PropertiesOption);
+            Options.Add(ProjectOrSolutionOption);
+            Options.Add(SolutionOption);
+            Options.Add(TestModulesFilterOption);
+            Options.Add(TestModulesRootDirectoryOption);
+            Options.Add(ResultsDirectoryOption);
+            Options.Add(ConfigFileOption);
+            Options.Add(DiagnosticOutputDirectoryOption);
+            Options.Add(MaxParallelTestModulesOption);
+            Options.Add(MinimumExpectedTestsOption);
+            Options.Add(ArchitectureOption);
+            Options.Add(EnvOption);
+            Options.Add(PropertiesOption);
             Options.Add(ConfigurationOption);
             Options.Add(FrameworkOption);
-            Options.Add(CommonOptions.OperatingSystemOption);
-            Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
+            Options.Add(OperatingSystemOption);
+            Options.Add(RuntimeOption);
             Options.Add(VerbosityOption);
-            Options.Add(CommonOptions.NoRestoreOption);
-            Options.Add(MicrosoftTestingPlatformOptions.NoBuildOption);
-            Options.Add(MicrosoftTestingPlatformOptions.NoAnsiOption);
-            Options.Add(MicrosoftTestingPlatformOptions.NoProgressOption);
-            Options.Add(MicrosoftTestingPlatformOptions.OutputOption);
-            Options.Add(MicrosoftTestingPlatformOptions.ListTestsOption);
-            Options.Add(MicrosoftTestingPlatformOptions.NoLaunchProfileOption);
-            Options.Add(MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption);
-            Options.Add(MicrosoftTestingPlatformOptions.MTPTargetOption);
+            Options.Add(NoRestoreOption);
+            Options.Add(NoBuildOption);
+            Options.Add(NoAnsiOption);
+            Options.Add(NoProgressOption);
+            Options.Add(OutputOption);
+            Options.Add(ListTestsOption);
+            Options.Add(NoLaunchProfileOption);
+            Options.Add(NoLaunchProfileArgumentsOption);
+            Options.Add(MTPTargetOption);
         }
 
         public IEnumerable<Action<HelpContext>> CustomHelpLayout()
@@ -132,43 +157,72 @@ public IEnumerable<Action<HelpContext>> CustomHelpLayout()
 
     public sealed class VSTest : TestCommandDefinition
     {
+        public static readonly Option<string> SettingsOption = VSTestOptions.SettingsOption;
+        public static readonly Option<bool> ListTestsOption = VSTestOptions.ListTestsOption;
+        public static readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
+        public static readonly Option<string> FilterOption = VSTestOptions.FilterOption;
+        public static readonly Option<IEnumerable<string>> AdapterOption = VSTestOptions.AdapterOption;
+        public static readonly Option<IEnumerable<string>> LoggerOption = VSTestOptions.LoggerOption;
+        public static readonly Option<string> OutputOption = VSTestOptions.OutputOption;
+        public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+        public static readonly Option<string> DiagOption = VSTestOptions.DiagOption;
+        public static readonly Option<bool> NoBuildOption = VSTestOptions.NoBuildOption;
+        public static readonly Option<string> ResultsOption = VSTestOptions.ResultsOption;
+        public static readonly Option<IEnumerable<string>> CollectOption = VSTestOptions.CollectOption;
+        public static readonly Option<bool> BlameOption = VSTestOptions.BlameOption;
+        public static readonly Option<bool> BlameCrashOption = VSTestOptions.BlameCrashOption;
+        public static readonly Option<string> BlameCrashDumpOption = VSTestOptions.BlameCrashDumpOption;
+        public static readonly Option<bool> BlameCrashAlwaysOption = VSTestOptions.BlameCrashAlwaysOption;
+        public static readonly Option<bool> BlameHangOption = VSTestOptions.BlameHangOption;
+        public static readonly Option<string> BlameHangDumpOption = VSTestOptions.BlameHangDumpOption;
+        public static readonly Option<string> BlameHangTimeoutOption = VSTestOptions.BlameHangTimeoutOption;
+        public static readonly Option<bool> NoLogoOption = VSTestOptions.NoLogoOption;
+        public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+        public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+        public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+        public static readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+        public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+        public static readonly Option<string[]> VsTestTargetOption = VSTestOptions.VsTestTargetOption;
+
         public VSTest()
             : base(CliCommandStrings.DotnetTestCommandVSTestDescription)
         {
             // We are on purpose not capturing the solution, project or directory here. We want to pass it to the
             // MSBuild command so we are letting it flow.
 
-            Options.Add(VSTestOptions.SettingsOption);
-            Options.Add(VSTestOptions.ListTestsOption);
-            Options.Add(CommonOptions.TestEnvOption);
-            Options.Add(VSTestOptions.FilterOption);
-            Options.Add(VSTestOptions.AdapterOption);
-            Options.Add(VSTestOptions.LoggerOption);
-            Options.Add(VSTestOptions.OutputOption);
-            Options.Add(CommonOptions.CreateArtifactsPathOption());
-            Options.Add(VSTestOptions.DiagOption);
-            Options.Add(VSTestOptions.NoBuildOption);
-            Options.Add(VSTestOptions.ResultsOption);
-            Options.Add(VSTestOptions.CollectOption);
-            Options.Add(VSTestOptions.BlameOption);
-            Options.Add(VSTestOptions.BlameCrashOption);
-            Options.Add(VSTestOptions.BlameCrashDumpOption);
-            Options.Add(VSTestOptions.BlameCrashAlwaysOption);
-            Options.Add(VSTestOptions.BlameHangOption);
-            Options.Add(VSTestOptions.BlameHangDumpOption);
-            Options.Add(VSTestOptions.BlameHangTimeoutOption);
-            Options.Add(VSTestOptions.NoLogoOption);
+            Options.Add(SettingsOption);
+            Options.Add(ListTestsOption);
+            Options.Add(TestEnvOption);
+            Options.Add(FilterOption);
+            Options.Add(AdapterOption);
+            Options.Add(LoggerOption);
+            Options.Add(OutputOption);
+            Options.Add(ArtifactsPathOption);
+            Options.Add(DiagOption);
+            Options.Add(NoBuildOption);
+            Options.Add(ResultsOption);
+            Options.Add(CollectOption);
+            Options.Add(BlameOption);
+            Options.Add(BlameCrashOption);
+            Options.Add(BlameCrashDumpOption);
+            Options.Add(BlameCrashAlwaysOption);
+            Options.Add(BlameHangOption);
+            Options.Add(BlameHangDumpOption);
+            Options.Add(BlameHangTimeoutOption);
+            Options.Add(NoLogoOption);
             Options.Add(ConfigurationOption);
             Options.Add(FrameworkOption);
-            Options.Add(CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
-            Options.Add(CommonOptions.NoRestoreOption);
-            Options.Add(CommonOptions.CreateInteractiveMsBuildForwardOption());
+            Options.Add(RuntimeOption);
+            Options.Add(NoRestoreOption);
+            Options.Add(InteractiveOption);
             Options.Add(VerbosityOption);
-            Options.Add(CommonOptions.ArchitectureOption);
-            Options.Add(CommonOptions.OperatingSystemOption);
-            Options.Add(CommonOptions.PropertiesOption);
-            Options.Add(CommonOptions.CreateDisableBuildServersOption());
-            Options.Add(VSTestOptions.VsTestTargetOption);
+            Options.Add(ArchitectureOption);
+            Options.Add(OperatingSystemOption);
+            Options.Add(PropertiesOption);
+            Options.Add(DisableBuildServersOption);
+            Options.Add(VsTestTargetOption);
         }
     }
 }

From 808c952138f9f5315eba496e598bac8d8124602e Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Mon, 5 Jan 2026 14:09:43 -0800
Subject: [PATCH 09/20] Test options - instance fields

---
 .../Commands/Test/MTP/MSBuildUtility.cs       |  30 +++--
 .../MTP/MicrosoftTestingPlatformOptions.cs    |  16 ++-
 .../MicrosoftTestingPlatformTestCommand.cs    |  26 +++--
 .../Commands/Test/MTP/TestApplication.cs      |   8 +-
 .../Test/MTP/TestModulesFilterHandler.cs      |   9 +-
 .../Commands/Test/MTP/ValidationUtility.cs    |  24 ++--
 .../Commands/Test/TestCommandDefinition.cs    | 108 +++++++++---------
 .../Commands/Test/VSTest/TestCommand.cs       |  20 ++--
 src/Cli/dotnet/CommonOptions.cs               |  20 +++-
 src/Cli/dotnet/Telemetry/TelemetryFilter.cs   |  15 +--
 .../TopLevelCommandNameAndOptionToLog.cs      |  10 +-
 .../GivenDotnetTestBuildsAndDiscoversTests.cs |  16 +--
 .../Test/GivenDotnetTestBuildsAndRunsHelp.cs  |  18 ++-
 ...tBuildsAndRunsTestBasedOnGlobbingFilter.cs |   8 +-
 .../Test/GivenDotnetTestBuildsAndRunsTests.cs |  44 +++----
 ...etTestBuildsAndRunsTestsForMultipleTFMs.cs |  10 +-
 ...tnetTestBuildsAndRunsTestsWithArtifacts.cs |   4 +-
 ...tBuildsAndRunsTestsWithDifferentOptions.cs | 100 ++++++++--------
 ...otnetTestRunsConsoleAppWithoutHandshake.cs |   2 +-
 19 files changed, 259 insertions(+), 229 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
index 43150668a9cc..5ec2bc7930b4 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
@@ -99,43 +99,45 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
 
     public static BuildOptions GetBuildOptions(ParseResult parseResult)
     {
+        var definition = (TestCommandDefinition.MicrosoftTestingPlatform)parseResult.CommandResult.Command;
+
         LoggerUtility.SeparateBinLogArguments(parseResult.UnmatchedTokens, out var binLogArgs, out var otherArgs);
 
         var msbuildArgs = parseResult.OptionValuesToBeForwarded(TestCommandParser.GetCommand())
             .Concat(binLogArgs);
 
-        string? resultsDirectory = parseResult.GetValue(MicrosoftTestingPlatformOptions.ResultsDirectoryOption);
+        string? resultsDirectory = parseResult.GetValue(definition.ResultsDirectoryOption);
         if (resultsDirectory is not null)
         {
             resultsDirectory = Path.GetFullPath(resultsDirectory);
         }
 
-        string? configFile = parseResult.GetValue(MicrosoftTestingPlatformOptions.ConfigFileOption);
+        string? configFile = parseResult.GetValue(definition.ConfigFileOption);
         if (configFile is not null)
         {
             configFile = Path.GetFullPath(configFile);
         }
 
-        string? diagnosticOutputDirectory = parseResult.GetValue(MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption);
+        string? diagnosticOutputDirectory = parseResult.GetValue(definition.DiagnosticOutputDirectoryOption);
         if (diagnosticOutputDirectory is not null)
         {
             diagnosticOutputDirectory = Path.GetFullPath(diagnosticOutputDirectory);
         }
 
         PathOptions pathOptions = new(
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption),
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.SolutionOption),
+            parseResult.GetValue(definition.ProjectOrSolutionOption),
+            parseResult.GetValue(definition.SolutionOption),
             resultsDirectory,
             configFile,
             diagnosticOutputDirectory);
 
         return new BuildOptions(
             pathOptions,
-            parseResult.GetValue(CommonOptions.NoRestoreOption),
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.NoBuildOption),
-            parseResult.HasOption(TestCommandDefinition.VerbosityOption) ? parseResult.GetValue(TestCommandDefinition.VerbosityOption) : null,
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.NoLaunchProfileOption),
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption),
+            parseResult.GetValue(definition.NoRestoreOption),
+            parseResult.GetValue(definition.NoBuildOption),
+            parseResult.HasOption(definition.VerbosityOption) ? parseResult.GetValue(definition.VerbosityOption) : null,
+            parseResult.GetValue(definition.NoLaunchProfileOption),
+            parseResult.GetValue(definition.NoLaunchProfileArgumentsOption),
             otherArgs,
             msbuildArgs);
     }
@@ -153,7 +155,13 @@ private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOption
             msbuildArgs.Add($"-verbosity:quiet");
         }
 
-        var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, MicrosoftTestingPlatformOptions.MTPTargetOption, TestCommandDefinition.VerbosityOption, CommonOptions.CreateNoLogoOption());
+        var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
+            msbuildArgs,
+            CommonOptions.PropertiesOption,
+            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget),
+            CommonOptions.CreateVerbosityOption(),
+            CommonOptions.CreateNoLogoOption());
 
         int result = new RestoringCommand(parsedMSBuildArgs, buildOptions.HasNoRestore).Execute();
 
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
index 16100ca88f7a..9caf500c2210 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
@@ -33,21 +33,27 @@ internal static class MicrosoftTestingPlatformOptions
         HelpName = CliCommandStrings.CmdRootPathName,
     };
 
-    public static readonly Option<string> ResultsDirectoryOption = new("--results-directory")
+    public const string ResultsDirectoryOptionName = "--results-directory";
+
+    public static readonly Option<string> ResultsDirectoryOption = new(ResultsDirectoryOptionName)
     {
         Description = CliCommandStrings.CmdResultsDirectoryDescription,
         HelpName = CliCommandStrings.CmdPathToResultsDirectory,
         Arity = ArgumentArity.ExactlyOne
     };
 
-    public static readonly Option<string> ConfigFileOption = new("--config-file")
+    public const string ConfigFileOptionName = "--config-file";
+
+    public static readonly Option<string> ConfigFileOption = new(ConfigFileOptionName)
     {
         Description = CliCommandStrings.CmdConfigFileDescription,
         HelpName = CliCommandStrings.CmdConfigFilePath,
         Arity = ArgumentArity.ExactlyOne
     };
 
-    public static readonly Option<string> DiagnosticOutputDirectoryOption = new("--diagnostic-output-directory")
+    public const string DiagnosticOutputDirectoryOptionName = "--diagnostic-output-directory";
+
+    public static readonly Option<string> DiagnosticOutputDirectoryOption = new(DiagnosticOutputDirectoryOptionName)
     {
         Description = CliCommandStrings.CmdDiagnosticOutputDirectoryDescription,
         HelpName = CliCommandStrings.CmdDiagnosticOutputDirectoryPath,
@@ -100,7 +106,9 @@ internal static class MicrosoftTestingPlatformOptions
         Arity = ArgumentArity.ExactlyOne
     };
 
-    public static readonly Option<string> ListTestsOption = new("--list-tests")
+    public const string ListTestsOptionName = "--list-tests";
+
+    public static readonly Option<string> ListTestsOption = new(ListTestsOptionName)
     {
         Description = CliCommandStrings.CmdListTestsDescription,
         Arity = ArgumentArity.Zero
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs
index b3e24c51a227..63d307b39fd6 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformTestCommand.cs
@@ -30,18 +30,20 @@ public int Run(ParseResult parseResult, bool isHelp)
 
     private int RunInternal(ParseResult parseResult, bool isHelp)
     {
+        var definition = (TestCommandDefinition.MicrosoftTestingPlatform)parseResult.CommandResult.Command;
+
         ValidationUtility.ValidateMutuallyExclusiveOptions(parseResult);
         ValidationUtility.ValidateSolutionOrProjectOrDirectoryOrModulesArePassedCorrectly(parseResult);
 
         int degreeOfParallelism = GetDegreeOfParallelism(parseResult);
         var testOptions = new TestOptions(
             IsHelp: isHelp,
-            IsDiscovery: parseResult.HasOption(MicrosoftTestingPlatformOptions.ListTestsOption),
-            EnvironmentVariables: parseResult.GetValue(CommonOptions.EnvOption) ?? ImmutableDictionary<string, string>.Empty);
+            IsDiscovery: parseResult.HasOption(definition.ListTestsOption),
+            EnvironmentVariables: parseResult.GetValue(definition.EnvOption) ?? ImmutableDictionary<string, string>.Empty);
 
         BuildOptions buildOptions = MSBuildUtility.GetBuildOptions(parseResult);
 
-        bool filterModeEnabled = parseResult.HasOption(MicrosoftTestingPlatformOptions.TestModulesFilterOption);
+        bool filterModeEnabled = parseResult.HasOption(definition.TestModulesFilterOption);
         TestApplicationActionQueue actionQueue;
         if (filterModeEnabled)
         {
@@ -80,8 +82,8 @@ private int RunInternal(ParseResult parseResult, bool isHelp)
         var exitCode = actionQueue.WaitAllActions();
         exitCode = _output.HasHandshakeFailure ? ExitCode.GenericFailure : exitCode;
         if (exitCode == ExitCode.Success &&
-            parseResult.HasOption(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption) &&
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption) is { } minimumExpectedTests &&
+            parseResult.HasOption(definition.MinimumExpectedTestsOption) &&
+            parseResult.GetValue(definition.MinimumExpectedTestsOption) is { } minimumExpectedTests &&
             _output.TotalTests < minimumExpectedTests)
         {
             exitCode = ExitCode.MinimumExpectedTestsPolicyViolation;
@@ -93,10 +95,12 @@ private int RunInternal(ParseResult parseResult, bool isHelp)
     [MemberNotNull(nameof(_output))]
     private void InitializeOutput(int degreeOfParallelism, ParseResult parseResult, TestOptions testOptions)
     {
+        var definition = (TestCommandDefinition.MicrosoftTestingPlatform)parseResult.CommandResult.Command;
+
         var console = new SystemConsole();
-        var showPassedTests = parseResult.GetValue(MicrosoftTestingPlatformOptions.OutputOption) == OutputOptions.Detailed;
-        var noProgress = parseResult.HasOption(MicrosoftTestingPlatformOptions.NoProgressOption);
-        var noAnsi = parseResult.HasOption(MicrosoftTestingPlatformOptions.NoAnsiOption);
+        var showPassedTests = parseResult.GetValue(definition.OutputOption) == OutputOptions.Detailed;
+        var noProgress = parseResult.HasOption(definition.NoProgressOption);
+        var noAnsi = parseResult.HasOption(definition.NoAnsiOption);
 
         // TODO: Replace this with proper CI detection that we already have in telemetry. https://github.com/microsoft/testfx/issues/5533#issuecomment-2838893327
         bool inCI = string.Equals(Environment.GetEnvironmentVariable("TF_BUILD"), "true", StringComparison.OrdinalIgnoreCase) || string.Equals(Environment.GetEnvironmentVariable("GITHUB_ACTIONS"), "true", StringComparison.OrdinalIgnoreCase);
@@ -109,7 +113,7 @@ private void InitializeOutput(int degreeOfParallelism, ParseResult parseResult,
             UseCIAnsi = inCI,
             ShowAssembly = true,
             ShowAssemblyStartAndComplete = true,
-            MinimumExpectedTests = parseResult.GetValue(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption),
+            MinimumExpectedTests = parseResult.GetValue(definition.MinimumExpectedTestsOption),
         });
 
         Console.CancelKeyPress += (s, e) =>
@@ -125,7 +129,9 @@ private void InitializeOutput(int degreeOfParallelism, ParseResult parseResult,
 
     private static int GetDegreeOfParallelism(ParseResult parseResult)
     {
-        var degreeOfParallelism = parseResult.GetValue(MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption);
+        var definition = (TestCommandDefinition.MicrosoftTestingPlatform)parseResult.CommandResult.Command;
+
+        var degreeOfParallelism = parseResult.GetValue(definition.MaxParallelTestModulesOption);
         if (degreeOfParallelism <= 0)
             degreeOfParallelism = Environment.ProcessorCount;
         return degreeOfParallelism;
diff --git a/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs b/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs
index be7a7371c707..17ecdccfb98a 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs
@@ -150,22 +150,22 @@ private string GetArguments()
 
         if (TestOptions.IsDiscovery)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ListTestsOption.Name}");
+            builder.Append($" {MicrosoftTestingPlatformOptions.ListTestsOptionName}");
         }
 
         if (_buildOptions.PathOptions.ResultsDirectoryPath is { } resultsDirectoryPath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ResultsDirectoryOption.Name} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
+            builder.Append($" {MicrosoftTestingPlatformOptions.ResultsDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
         }
 
         if (_buildOptions.PathOptions.ConfigFilePath is { } configFilePath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ConfigFileOption.Name} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
+            builder.Append($" {MicrosoftTestingPlatformOptions.ConfigFileOptionName} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
         }
 
         if (_buildOptions.PathOptions.DiagnosticOutputDirectoryPath is { } diagnosticOutputDirectoryPath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption.Name} {ArgumentEscaper.EscapeSingleArg(diagnosticOutputDirectoryPath)}");
+            builder.Append($" {MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(diagnosticOutputDirectoryPath)}");
         }
 
         foreach (var arg in _buildOptions.UnmatchedTokens)
diff --git a/src/Cli/dotnet/Commands/Test/MTP/TestModulesFilterHandler.cs b/src/Cli/dotnet/Commands/Test/MTP/TestModulesFilterHandler.cs
index 37f46fc0984d..b2e30c6b62f4 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/TestModulesFilterHandler.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/TestModulesFilterHandler.cs
@@ -5,7 +5,6 @@
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Commands.Test.Terminal;
-using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.FileSystemGlobbing;
 
@@ -18,15 +17,17 @@ internal sealed class TestModulesFilterHandler(TestApplicationActionQueue action
 
     public bool RunWithTestModulesFilter(ParseResult parseResult)
     {
+        var definition = (TestCommandDefinition.MicrosoftTestingPlatform)parseResult.CommandResult.Command;
+
         // If the module path pattern(s) was provided, we will use that to filter the test modules
-        string testModules = parseResult.GetValue(MicrosoftTestingPlatformOptions.TestModulesFilterOption)!;
+        string testModules = parseResult.GetValue(definition.TestModulesFilterOption)!;
 
         // If the root directory was provided, we will use that to search for the test modules
         // Otherwise, we will use the current directory
         string? rootDirectory = Directory.GetCurrentDirectory();
-        if (parseResult.HasOption(MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption))
+        if (parseResult.HasOption(definition.TestModulesRootDirectoryOption))
         {
-            rootDirectory = parseResult.GetValue(MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption);
+            rootDirectory = parseResult.GetValue(definition.TestModulesRootDirectoryOption);
 
             // If the root directory is not valid, we simply return
             if (string.IsNullOrEmpty(rootDirectory) || !Directory.Exists(rootDirectory))
diff --git a/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs b/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs
index 1e16d5cea36a..d6630475269f 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs
@@ -13,37 +13,39 @@ internal static class ValidationUtility
 {
     public static void ValidateMutuallyExclusiveOptions(ParseResult parseResult)
     {
+        var definition = (TestCommandDefinition.MicrosoftTestingPlatform)parseResult.CommandResult.Command;
+
         ValidatePathOptions(parseResult);
         ValidateOptionsIrrelevantToModulesFilter(parseResult);
 
-        static void ValidatePathOptions(ParseResult parseResult)
+        void ValidatePathOptions(ParseResult parseResult)
         {
             var count = 0;
-            if (parseResult.HasOption(MicrosoftTestingPlatformOptions.TestModulesFilterOption))
+            if (parseResult.HasOption(definition.TestModulesFilterOption))
                 count++;
 
-            if (parseResult.HasOption(MicrosoftTestingPlatformOptions.SolutionOption))
+            if (parseResult.HasOption(definition.SolutionOption))
                 count++;
 
-            if (parseResult.HasOption(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption))
+            if (parseResult.HasOption(definition.ProjectOrSolutionOption))
                 count++;
 
             if (count > 1)
                 throw new GracefulException(CliCommandStrings.CmdMultipleBuildPathOptionsErrorDescription);
         }
 
-        static void ValidateOptionsIrrelevantToModulesFilter(ParseResult parseResult)
+        void ValidateOptionsIrrelevantToModulesFilter(ParseResult parseResult)
         {
-            if (!parseResult.HasOption(MicrosoftTestingPlatformOptions.TestModulesFilterOption))
+            if (!parseResult.HasOption(definition.TestModulesFilterOption))
             {
                 return;
             }
 
-            if (parseResult.HasOption(CommonOptions.ArchitectureOption) ||
-                parseResult.HasOption(TestCommandDefinition.ConfigurationOption) ||
-                parseResult.HasOption(TestCommandDefinition.FrameworkOption) ||
-                parseResult.HasOption(CommonOptions.OperatingSystemOption) ||
-                parseResult.HasOption(CommonOptions.RuntimeOptionName))
+            if (parseResult.HasOption(definition.ArchitectureOption) ||
+                parseResult.HasOption(definition.ConfigurationOption) ||
+                parseResult.HasOption(definition.FrameworkOption) ||
+                parseResult.HasOption(definition.OperatingSystemOption) ||
+                parseResult.HasOption(definition.RuntimeOption))
             {
                 throw new GracefulException(CliCommandStrings.CmdOptionCannotBeUsedWithTestModulesDescription);
             }
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index 61dcc40150af..d3142439b5d5 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -16,11 +16,11 @@ internal abstract class TestCommandDefinition : Command
 {
     private const string Link = "https://aka.ms/dotnet-test";
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
 
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
     public TestCommandDefinition(string description)
         : base("test", description)
@@ -94,29 +94,29 @@ private sealed class GlobalJsonTestNode
 
     public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHelp
     {
-        public static readonly Option<string> ProjectOrSolutionOption = MicrosoftTestingPlatformOptions.ProjectOrSolutionOption;
-        public static readonly Option<string> SolutionOption = MicrosoftTestingPlatformOptions.SolutionOption;
-        public static readonly Option<string> TestModulesFilterOption = MicrosoftTestingPlatformOptions.TestModulesFilterOption;
-        public static readonly Option<string> TestModulesRootDirectoryOption = MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption;
-        public static readonly Option<string> ResultsDirectoryOption = MicrosoftTestingPlatformOptions.ResultsDirectoryOption;
-        public static readonly Option<string> ConfigFileOption = MicrosoftTestingPlatformOptions.ConfigFileOption;
-        public static readonly Option<string> DiagnosticOutputDirectoryOption = MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption;
-        public static readonly Option<int> MaxParallelTestModulesOption = MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption;
-        public static readonly Option<int> MinimumExpectedTestsOption = MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption;
-        public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-        public static readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
-        public static readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
-        public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-        public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
-        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-        public static readonly Option<bool> NoBuildOption = MicrosoftTestingPlatformOptions.NoBuildOption;
-        public static readonly Option<bool> NoAnsiOption = MicrosoftTestingPlatformOptions.NoAnsiOption;
-        public static readonly Option<bool> NoProgressOption = MicrosoftTestingPlatformOptions.NoProgressOption;
-        public static readonly Option<OutputOptions> OutputOption = MicrosoftTestingPlatformOptions.OutputOption;
-        public static readonly Option<string> ListTestsOption = MicrosoftTestingPlatformOptions.ListTestsOption;
-        public static readonly Option<bool> NoLaunchProfileOption = MicrosoftTestingPlatformOptions.NoLaunchProfileOption;
-        public static readonly Option<bool> NoLaunchProfileArgumentsOption = MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption;
-        public static readonly Option<string[]> MTPTargetOption = MicrosoftTestingPlatformOptions.MTPTargetOption;
+        public readonly Option<string> ProjectOrSolutionOption = MicrosoftTestingPlatformOptions.ProjectOrSolutionOption;
+        public readonly Option<string> SolutionOption = MicrosoftTestingPlatformOptions.SolutionOption;
+        public readonly Option<string> TestModulesFilterOption = MicrosoftTestingPlatformOptions.TestModulesFilterOption;
+        public readonly Option<string> TestModulesRootDirectoryOption = MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption;
+        public readonly Option<string> ResultsDirectoryOption = MicrosoftTestingPlatformOptions.ResultsDirectoryOption;
+        public readonly Option<string> ConfigFileOption = MicrosoftTestingPlatformOptions.ConfigFileOption;
+        public readonly Option<string> DiagnosticOutputDirectoryOption = MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption;
+        public readonly Option<int> MaxParallelTestModulesOption = MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption;
+        public readonly Option<int> MinimumExpectedTestsOption = MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption;
+        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public readonly Option<bool> NoBuildOption = MicrosoftTestingPlatformOptions.NoBuildOption;
+        public readonly Option<bool> NoAnsiOption = MicrosoftTestingPlatformOptions.NoAnsiOption;
+        public readonly Option<bool> NoProgressOption = MicrosoftTestingPlatformOptions.NoProgressOption;
+        public readonly Option<OutputOptions> OutputOption = MicrosoftTestingPlatformOptions.OutputOption;
+        public readonly Option<string> ListTestsOption = MicrosoftTestingPlatformOptions.ListTestsOption;
+        public readonly Option<bool> NoLaunchProfileOption = MicrosoftTestingPlatformOptions.NoLaunchProfileOption;
+        public readonly Option<bool> NoLaunchProfileArgumentsOption = MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption;
+        public readonly Option<string[]> MTPTargetOption = MicrosoftTestingPlatformOptions.MTPTargetOption;
 
         public ICustomHelp? CustomHelpLayoutProvider { get; set; }
 
@@ -157,34 +157,34 @@ public IEnumerable<Action<HelpContext>> CustomHelpLayout()
 
     public sealed class VSTest : TestCommandDefinition
     {
-        public static readonly Option<string> SettingsOption = VSTestOptions.SettingsOption;
-        public static readonly Option<bool> ListTestsOption = VSTestOptions.ListTestsOption;
-        public static readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
-        public static readonly Option<string> FilterOption = VSTestOptions.FilterOption;
-        public static readonly Option<IEnumerable<string>> AdapterOption = VSTestOptions.AdapterOption;
-        public static readonly Option<IEnumerable<string>> LoggerOption = VSTestOptions.LoggerOption;
-        public static readonly Option<string> OutputOption = VSTestOptions.OutputOption;
-        public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-        public static readonly Option<string> DiagOption = VSTestOptions.DiagOption;
-        public static readonly Option<bool> NoBuildOption = VSTestOptions.NoBuildOption;
-        public static readonly Option<string> ResultsOption = VSTestOptions.ResultsOption;
-        public static readonly Option<IEnumerable<string>> CollectOption = VSTestOptions.CollectOption;
-        public static readonly Option<bool> BlameOption = VSTestOptions.BlameOption;
-        public static readonly Option<bool> BlameCrashOption = VSTestOptions.BlameCrashOption;
-        public static readonly Option<string> BlameCrashDumpOption = VSTestOptions.BlameCrashDumpOption;
-        public static readonly Option<bool> BlameCrashAlwaysOption = VSTestOptions.BlameCrashAlwaysOption;
-        public static readonly Option<bool> BlameHangOption = VSTestOptions.BlameHangOption;
-        public static readonly Option<string> BlameHangDumpOption = VSTestOptions.BlameHangDumpOption;
-        public static readonly Option<string> BlameHangTimeoutOption = VSTestOptions.BlameHangTimeoutOption;
-        public static readonly Option<bool> NoLogoOption = VSTestOptions.NoLogoOption;
-        public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
-        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-        public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-        public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-        public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-        public static readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
-        public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-        public static readonly Option<string[]> VsTestTargetOption = VSTestOptions.VsTestTargetOption;
+        public readonly Option<string> SettingsOption = VSTestOptions.SettingsOption;
+        public readonly Option<bool> ListTestsOption = VSTestOptions.ListTestsOption;
+        public readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
+        public readonly Option<string> FilterOption = VSTestOptions.FilterOption;
+        public readonly Option<IEnumerable<string>> AdapterOption = VSTestOptions.AdapterOption;
+        public readonly Option<IEnumerable<string>> LoggerOption = VSTestOptions.LoggerOption;
+        public readonly Option<string> OutputOption = VSTestOptions.OutputOption;
+        public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+        public readonly Option<string> DiagOption = VSTestOptions.DiagOption;
+        public readonly Option<bool> NoBuildOption = VSTestOptions.NoBuildOption;
+        public readonly Option<string> ResultsOption = VSTestOptions.ResultsOption;
+        public readonly Option<IEnumerable<string>> CollectOption = VSTestOptions.CollectOption;
+        public readonly Option<bool> BlameOption = VSTestOptions.BlameOption;
+        public readonly Option<bool> BlameCrashOption = VSTestOptions.BlameCrashOption;
+        public readonly Option<string> BlameCrashDumpOption = VSTestOptions.BlameCrashDumpOption;
+        public readonly Option<bool> BlameCrashAlwaysOption = VSTestOptions.BlameCrashAlwaysOption;
+        public readonly Option<bool> BlameHangOption = VSTestOptions.BlameHangOption;
+        public readonly Option<string> BlameHangDumpOption = VSTestOptions.BlameHangDumpOption;
+        public readonly Option<string> BlameHangTimeoutOption = VSTestOptions.BlameHangTimeoutOption;
+        public readonly Option<bool> NoLogoOption = VSTestOptions.NoLogoOption;
+        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+        public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+        public readonly Option<string[]> VsTestTargetOption = VSTestOptions.VsTestTargetOption;
 
         public VSTest()
             : base(CliCommandStrings.DotnetTestCommandVSTestDescription)
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
index 7668b8bc4cc7..62a011caa3a9 100644
--- a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
+++ b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
@@ -189,6 +189,8 @@ public static TestCommand FromArgs(string[] args, string? testSessionCorrelation
 
     private static TestCommand FromParseResult(ParseResult result, string[] settings, string testSessionCorrelationId, string[] additionalBuildProperties, string? msbuildPath = null)
     {
+        var definition = (TestCommandDefinition.VSTest)result.CommandResult.Command;
+
         result.ShowHelpOrErrorIfAppropriate();
 
         // Extra msbuild properties won't be parsed and so end up in the UnmatchedTokens list. In addition to those
@@ -200,7 +202,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             : result.UnmatchedTokens;
 
         var parsedArgs =
-            result.OptionValuesToBeForwarded(TestCommandParser.GetCommand()) // all msbuild-recognized tokens
+            result.OptionValuesToBeForwarded(definition.Options) // all msbuild-recognized tokens
                 .Concat(unMatchedNonSettingsArgs); // all tokens that the test-parser doesn't explicitly track (minus the settings tokens)
 
         VSTestTrace.SafeWriteTrace(() => $"MSBuild args from forwarded options: {string.Join(", ", parsedArgs)}");
@@ -216,7 +218,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             msbuildArgs.Add($"-property:VSTestCLIRunSettings=\"{runSettingsArg}\"");
         }
 
-        string? verbosityArg = result.ForwardedOptionValues(TestCommandParser.GetCommand(), "--verbosity")?.SingleOrDefault() ?? null;
+        string? verbosityArg = result.ForwardedOptionValues(definition, "--verbosity")?.SingleOrDefault() ?? null;
         if (verbosityArg != null)
         {
             string[] verbosity = verbosityArg.Split(':', 2);
@@ -233,14 +235,14 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             msbuildArgs.Add($"-property:VSTestSessionCorrelationId={testSessionCorrelationId}");
         }
 
-        bool noRestore = result.GetValue(CommonOptions.NoRestoreOption) || result.GetValue(VSTestOptions.NoBuildOption);
+        bool noRestore = result.GetValue(definition.NoRestoreOption) || result.GetValue(definition.NoBuildOption);
 
         var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
             msbuildArgs,
             CommonOptions.PropertiesOption,
             CommonOptions.RestorePropertiesOption,
-            VSTestOptions.VsTestTargetOption,
-            TestCommandDefinition.VerbosityOption,
+            CommonOptions.CreateRequiredMSBuildTargetOption("VSTest"),
+            CommonOptions.CreateVerbosityOption(),
             CommonOptions.CreateNoLogoOption())
             .CloneWithNoLogo(true);
 
@@ -250,7 +252,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             msbuildPath);
 
         // Apply environment variables provided by the user via --environment (-e) option, if present
-        if (result.GetValue(CommonOptions.TestEnvOption) is { } environmentVariables)
+        if (result.GetValue(definition.TestEnvOption) is { } environmentVariables)
         {
             foreach (var (name, value) in environmentVariables)
             {
@@ -288,9 +290,11 @@ internal static int RunArtifactPostProcessingIfNeeded(string testSessionCorrelat
 
         var artifactsPostProcessArgs = new List<string> { "--artifactsProcessingMode-postprocess", $"--testSessionCorrelationId:{testSessionCorrelationId}" };
 
-        if (parseResult.GetResult(VSTestOptions.DiagOption) is not null)
+        var definition = (TestCommandDefinition.VSTest)parseResult.CommandResult.Command;
+
+        if (parseResult.GetResult(definition.DiagOption) is not null)
         {
-            artifactsPostProcessArgs.Add($"--diag:{parseResult.GetValue(VSTestOptions.DiagOption)}");
+            artifactsPostProcessArgs.Add($"--diag:{parseResult.GetValue(definition.DiagOption)}");
         }
 
         try
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index db867126868a..76bdf1d2235f 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -168,8 +168,10 @@ public static Option<VerbosityOptions> CreateHiddenVerbosityOption() =>
         .ForwardAsSingle(o => $"--verbosity:{o}")
         .AggregateRepeatedTokens();
 
+    public const string FrameworkOptionName = "--framework";
+
     public static Option<string> CreateFrameworkOption(string description) =>
-        new Option<string>("--framework", "-f")
+        new Option<string>(FrameworkOptionName, "-f")
         {
             Description = description,
             HelpName = CliStrings.FrameworkArgumentName,
@@ -215,8 +217,10 @@ public static Option<bool> CreateUseCurrentRuntimeOption(string description) =>
             Arity = ArgumentArity.Zero
         }.ForwardAs("--property:UseCurrentRuntimeIdentifier=True");
 
+    public const string ConfigurationOptionName = "--configuration";
+
     public static Option<string?> CreateConfigurationOption(string description) =>
-        new Option<string?>("--configuration", "-c")
+        new Option<string?>(ConfigurationOptionName, "-c")
         {
             Description = description,
             HelpName = CliStrings.ConfigurationArgumentName,
@@ -387,11 +391,17 @@ private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(Arg
         return result;
     }
 
-    public static readonly Option<string> TestPlatformOption = new("--Platform");
+    public const string TestPlatformOptionName = "--Platform";
+
+    public static readonly Option<string> TestPlatformOption = new(TestPlatformOptionName);
+
+    public const string TestFrameworkOptionName = "--Framework";
+
+    public static readonly Option<string> TestFrameworkOption = new(TestFrameworkOptionName);
 
-    public static readonly Option<string> TestFrameworkOption = new("--Framework");
+    public const string TestLoggerOptionName = "--logger";
 
-    public static readonly Option<string[]> TestLoggerOption = new("--logger");
+    public static readonly Option<string[]> TestLoggerOption = new(TestLoggerOptionName);
 
     /// <summary>
     /// Creates an implementation of the <c>--no-logo</c> option.
diff --git a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
index 76c30928a112..cbf561e0dc73 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
@@ -110,32 +110,27 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["build", "publish"],
-            optionsToLog: [ BuildCommandDefinition.FrameworkOption, PublishCommandDefinition.FrameworkOption,
-                BuildCommandDefinition.RuntimeOption, PublishCommandDefinition.RuntimeOption, BuildCommandDefinition.ConfigurationOption,
-                PublishCommandDefinition.ConfigurationOption ]
+            optionsToLog: [ CommonOptions.FrameworkOptionName, CommonOptions.RuntimeOptionName, CommonOptions.ConfigurationOptionName ]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["run", "clean", "test"],
-            optionsToLog: [ RunCommandDefinition.FrameworkOption, CleanCommandDefinition.FrameworkOption,
-                TestCommandDefinition.FrameworkOption, RunCommandDefinition.ConfigurationOption, CleanCommandDefinition.ConfigurationOption,
-                TestCommandDefinition.ConfigurationOption ]
+            optionsToLog: [CommonOptions.FrameworkOptionName, CommonOptions.ConfigurationOptionName]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["pack"],
-            optionsToLog: [PackCommandDefinition.ConfigurationOption]
+            optionsToLog: [CommonOptions.ConfigurationOptionName]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["vstest"],
-            optionsToLog: [ CommonOptions.TestPlatformOption,
-                CommonOptions.TestFrameworkOption, CommonOptions.TestLoggerOption ]
+            optionsToLog: [CommonOptions.TestPlatformOptionName, CommonOptions.TestFrameworkOptionName, CommonOptions.TestLoggerOptionName]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["publish"],
-            optionsToLog: [PublishCommandDefinition.RuntimeOption]
+            optionsToLog: [CommonOptions.RuntimeOptionName]
         ),
         new AllowListToSendVerbSecondVerbFirstArgument(["workload", "tool", "new"]),
     ];
diff --git a/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs b/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs
index 38ed7114f297..62d9d6e93630 100644
--- a/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs
+++ b/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs
@@ -13,19 +13,19 @@ namespace Microsoft.DotNet.Cli.Telemetry;
 
 internal class TopLevelCommandNameAndOptionToLog(
     HashSet<string> topLevelCommandName,
-    HashSet<Option> optionsToLog) : IParseResultLogRule
+    HashSet<string> optionsToLog) : IParseResultLogRule
 {
     private HashSet<string> _topLevelCommandName { get; } = topLevelCommandName;
-    private HashSet<Option> _optionsToLog { get; } = optionsToLog;
+    private HashSet<string> _optionsToLog { get; } = optionsToLog;
 
     public List<ApplicationInsightsEntryFormat> AllowList(ParseResult parseResult, Dictionary<string, double> measurements = null)
     {
         var topLevelCommandName = parseResult.RootSubCommandResult();
         var result = new List<ApplicationInsightsEntryFormat>();
-        foreach (var option in _optionsToLog)
+        foreach (var optionName in _optionsToLog)
         {
             if (_topLevelCommandName.Contains(topLevelCommandName)
-                && parseResult.GetResult(option) is OptionResult optionResult
+                && parseResult.GetResult(optionName) is OptionResult optionResult
                 && !parseResult.Errors.Any(error => error.SymbolResult == optionResult)
                 && optionResult.GetValueOrDefault<object>() is object optionValue
                 && optionValue is not null)
@@ -35,7 +35,7 @@ public List<ApplicationInsightsEntryFormat> AllowList(ParseResult parseResult, D
                     new Dictionary<string, string>
                     {
                         { "verb", topLevelCommandName},
-                        { option.Name.RemovePrefix(), Stringify(optionValue) }
+                        { optionName.RemovePrefix(), Stringify(optionValue) }
                     },
                     measurements));
             }
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndDiscoversTests.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndDiscoversTests.cs
index 6435efdf0fcd..eaf2dcfa49cf 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndDiscoversTests.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndDiscoversTests.cs
@@ -24,7 +24,7 @@ public void DiscoverTestProjectWithNoTests_ShouldReturnExitCodeGenericFailure(st
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--list-tests", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -47,7 +47,7 @@ public void DiscoverMultipleTestProjectsWithNoTests_ShouldReturnExitCodeGenericF
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--list-tests", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -70,7 +70,7 @@ public void DiscoverTestProjectWithTests_ShouldReturnExitCodeSuccess(string conf
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--list-tests", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -91,7 +91,7 @@ public void DiscoverMultipleTestProjectsWithTests_ShouldReturnExitCodeSuccess(st
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--list-tests", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -116,7 +116,7 @@ public void DiscoverProjectWithMSTestMetaPackageAndMultipleTFMsWithTests_ShouldR
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--list-tests", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -137,7 +137,7 @@ public void DiscoverTestProjectsWithHybridModeTestRunners_ShouldReturnExitCodeGe
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--list-tests", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -157,8 +157,8 @@ public void DiscoverTestProjectWithCustomRunArgumentsAndTestEscaping(string conf
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ListTestsOption.Name,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                    .Execute("--list-tests",
+                                             "-c", configuration,
                                              "-p:RunArguments=--hello world \"\" world2",
                                              "Another arg with spaces",
                                              "My other arg with spaces",
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsHelp.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsHelp.cs
index af5ed910bc00..7c6b039a0f99 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsHelp.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsHelp.cs
@@ -23,7 +23,7 @@ public void RunHelpOnTestProject_ShouldReturnExitCodeSuccess(string configuratio
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CliConstants.HelpOptionKey, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute(CliConstants.HelpOptionKey, "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -47,7 +47,7 @@ public void RunHelpOnMultipleTestProjects_ShouldReturnExitCodeSuccess(string con
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CliConstants.HelpOptionKey, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute(CliConstants.HelpOptionKey, "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -72,22 +72,18 @@ public void RunHelpCommand_ShouldNotShowDuplicateOptions(string configuration)
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CliConstants.HelpOptionKey, TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute(CliConstants.HelpOptionKey, "-c", configuration);
 
             // Parse the help output to extract option names
             var helpOutput = result.StdOut;
 
-            // Check for specific options we care about
-            string outputOptionName = MicrosoftTestingPlatformOptions.OutputOption.Name; // --output
-            string noAnsiOptionName = MicrosoftTestingPlatformOptions.NoAnsiOption.Name; // --no-ansi
-
             // Count occurrences of each option in the help output
-            int outputOptionCount = CountOptionOccurrences(helpOutput!, outputOptionName);
-            int noAnsiOptionCount = CountOptionOccurrences(helpOutput!, noAnsiOptionName);
+            int outputOptionCount = CountOptionOccurrences(helpOutput!, "--output");
+            int noAnsiOptionCount = CountOptionOccurrences(helpOutput!, "--no-ansi");
 
             // Assert that each option appears only once
-            outputOptionCount.Should().Be(1, $"Option '{outputOptionName}' should not appear more than once in help output");
-            noAnsiOptionCount.Should().Be(1, $"Option '{noAnsiOptionName}' should not appear more than once in help output");
+            outputOptionCount.Should().Be(1, $"Option '--output' should not appear more than once in help output");
+            noAnsiOptionCount.Should().Be(1, $"Option '--no-ansi' should not appear more than once in help output");
 
             result.ExitCode.Should().Be(ExitCodes.Success);
         }
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestBasedOnGlobbingFilter.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestBasedOnGlobbingFilter.cs
index 2a82eca0a169..eba16e82a7cc 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestBasedOnGlobbingFilter.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestBasedOnGlobbingFilter.cs
@@ -28,7 +28,7 @@ public void RunTestProjectWithFilterOfDll_ShouldReturnExitCodeSuccess()
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.TestModulesFilterOption.Name, $"**/bin/**/Debug/{ToolsetInfo.CurrentTargetFramework}/TestProject.dll".Replace('/', Path.DirectorySeparatorChar));
+                                    .Execute("--test-modules", $"**/bin/**/Debug/{ToolsetInfo.CurrentTargetFramework}/TestProject.dll".Replace('/', Path.DirectorySeparatorChar));
 
             // Assert that the bin folder hasn't been modified
             Assert.Equal(binDirectoryLastWriteTime, binDirectory?.LastWriteTime);
@@ -70,7 +70,7 @@ public void RunTestProjectsWithFilterOfDll_ShouldReturnExitCodeGenericFailure()
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.TestModulesFilterOption.Name, filterExpression);
+                                    .Execute("--test-modules", filterExpression);
 
             // Assert that the bin folder hasn't been modified
             Assert.Equal(binDirectoryLastWriteTime, binDirectory?.LastWriteTime);
@@ -108,8 +108,8 @@ public void RunTestProjectWithFilterOfDllWithRootDirectory_ShouldReturnExitCodeS
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .WithTraceOutput()
-                                    .Execute(MicrosoftTestingPlatformOptions.TestModulesFilterOption.Name, $"**/bin/**/Debug/{ToolsetInfo.CurrentTargetFramework}/TestProject.dll".Replace('/', Path.DirectorySeparatorChar),
-                                    MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption.Name, testInstance.TestRoot);
+                                    .Execute("--test-modules", $"**/bin/**/Debug/{ToolsetInfo.CurrentTargetFramework}/TestProject.dll".Replace('/', Path.DirectorySeparatorChar),
+                                    "--root-directory", testInstance.TestRoot);
 
             if (!TestContext.IsLocalized())
             {
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
index 3ccb65185fc5..19a31f9c663b 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
@@ -28,7 +28,7 @@ public void RunTestProjectWithNoTests_ShouldReturnExitCodeZeroTests(string confi
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -53,7 +53,7 @@ public void RunTestProjectWithWithRetryFeature_ShouldSucceed(string configuratio
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -80,7 +80,7 @@ public void RunMultipleTestProjectsWithNoTests_ShouldReturnExitCodeZeroTests(str
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -106,7 +106,7 @@ public void RunTestProjectWithTests_ShouldReturnExitCodeSuccess(string configura
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -154,7 +154,7 @@ public void RunTestProjectWithTestsAndLaunchSettings_ShouldReturnExitCodeSuccess
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .WithEnvironmentVariable("TEST_ENV_VAR", "TestValue1")
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -184,8 +184,8 @@ public void RunTestProjectWithTestsAndNoLaunchSettings_ShouldReturnExitCodeSucce
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
-                                        TestCommandDefinition.ConfigurationOption.Name, configuration,
-                                        MicrosoftTestingPlatformOptions.NoLaunchProfileOption.Name);
+                                        "-c", configuration,
+                                        "--no-launch-profile");
 
             result.StdOut.Should()
                 .Contain("FAILED to find argument from launchSettings.json")
@@ -215,7 +215,7 @@ public void RunTestProjectWithTestsAndLaunchSettingsAndExecutableProfile()
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                 .WithWorkingDirectory(testInstance.Path)
                 .Execute(
-                    TestCommandDefinition.ConfigurationOption.Name, TestingConstants.Debug);
+                    "-c", TestingConstants.Debug);
 
             result.StdOut.Should()
                 .Contain("Using launch settings from")
@@ -234,8 +234,8 @@ public void RunTestProjectWithTestsAndNoLaunchSettingsArguments_ShouldReturnExit
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
-                                        TestCommandDefinition.ConfigurationOption.Name, configuration,
-                                        MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption.Name, "true");
+                                        "-c", configuration,
+                                        "--no-launch-profile-arguments", "true");
 
             result.StdOut.Should()
                 .Contain("Using launch settings from")
@@ -253,7 +253,7 @@ public void RunMultipleTestProjectsWithFailingTests_ShouldReturnExitCodeAtLeastO
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -279,7 +279,7 @@ public void RunMultipleTestProjectsWithDifferentFailures_ShouldReturnExitCodeGen
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute("--minimum-expected-tests 2",
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -308,7 +308,7 @@ public void RunTestProjectsWithHybridModeTestRunners_ShouldReturnExitCodeGeneric
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -328,7 +328,7 @@ public void RunTestProjectsWithClassLibraryHavingIsTestProjectAndMTPProject_Shou
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -348,7 +348,7 @@ public void RunOnEmptyFolder_ShouldReturnExitCodeGenericFailure(string configura
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -368,7 +368,7 @@ public void RunOnMultipleProjectFoldersWithoutSolutionFile_ShouldReturnExitCodeG
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -388,7 +388,7 @@ public void RunOnProjectWithSolutionFile_ShouldReturnExitCodeGenericFailure(stri
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -409,8 +409,8 @@ public void RunOnProjectWithClassLibrary_ShouldReturnExitCodeSuccess(
                 .WithSource();
 
             string[] args = useFrameworkOption
-                ? new[] { TestCommandDefinition.ConfigurationOption.Name, configuration, TestCommandDefinition.FrameworkOption.Name, ToolsetInfo.CurrentTargetFramework }
-                : new[] { TestCommandDefinition.ConfigurationOption.Name, configuration };
+                ? new[] { "-c", configuration, "-f", ToolsetInfo.CurrentTargetFramework }
+                : new[] { "-c", configuration };
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
@@ -443,7 +443,7 @@ public void RunningWithGlobalPropertyShouldProperlyPropagate(string configuratio
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
-                                        TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                        "-c", configuration,
                                         CommonOptions.PropertiesOption.Name, "PROPERTY_TO_ENABLE_MTP=1");
 
             if (!TestContext.IsLocalized())
@@ -488,7 +488,7 @@ public void RunMTPSolutionWithMinimumExpectedTests(string value, int expectedExi
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                 .WithWorkingDirectory(testInstance.Path)
-                .Execute(MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption.Name, value);
+                .Execute("--minimum-expected-tests", value);
 
             result.ExitCode.Should().Be(expectedExitCode);
         }
@@ -570,7 +570,7 @@ public void RunTestProjectWithEnvVariable(string configuration)
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
-                                        TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                        "-c", configuration,
                                         CommonOptions.EnvOption.Name, "DUMMY_TEST_ENV_VAR=ENV_VAR_CMD_LINE");
 
             if (!TestContext.IsLocalized())
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs
index 5afb57f537ff..90e3f6edd781 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs
@@ -27,7 +27,7 @@ public void RunMultipleProjectWithDifferentTFMs_ShouldReturnExitCodeGenericFailu
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -67,7 +67,7 @@ public void RunProjectWithMultipleTFMs_ShouldReturnExitCodeGenericFailure(string
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -155,8 +155,8 @@ public void RunProjectWithMultipleTFMsWithArchOption_ShouldReturnExitCodeGeneric
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration,
-                                    CommonOptions.ArchitectureOption.Name, arch);
+                                    .Execute("-c", configuration,
+                                    "--arch", arch);
 
             if (!TestContext.IsLocalized())
             {
@@ -183,7 +183,7 @@ public void RunProjectWithMSTestMetaPackageAndMultipleTFMs_ShouldReturnExitCodeG
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithArtifacts.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithArtifacts.cs
index 321d34f0ef48..f8c76d625d8c 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithArtifacts.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithArtifacts.cs
@@ -23,7 +23,7 @@ public void RunTestProjectWithFailingTestsAndFileArtifacts_ShouldReturnExitCodeG
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -60,7 +60,7 @@ public void RunTestProjectWithCodeCoverage_ShouldReturnExitCodeGenericFailure(st
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute("--coverage", TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--coverage", "-c", configuration);
 
             if (!TestContext.IsLocalized())
             {
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
index 7883e1f6e647..9a405e23741b 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
@@ -26,8 +26,8 @@ public void RunWithProjectPathWithFailingTests_ShouldReturnExitCodeGenericFailur
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, testProjectPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--project", testProjectPath,
+                                    "--configuration", configuration);
 
             Regex.Matches(result.StdOut!, RegexPatternHelper.GenerateProjectRegexPattern("TestProject", true, configuration, "exec", addVersionAndArchPattern: false));
 
@@ -46,7 +46,7 @@ public void RunWithSolutionPathWithFailingTests_ShouldReturnExitCodeAtLeastOneTe
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(projectOrSolution, testSolutionPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Failed, true, configuration), result.StdOut);
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("OtherTestProject", TestingConstants.Passed, true, configuration), result.StdOut);
@@ -66,7 +66,7 @@ public void RunWithSolutionFilterPathWithFailingTests_ShouldReturnExitCodeGeneri
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(projectOrSolution, testSolutionPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Failed, true, configuration), result.StdOut);
             Assert.DoesNotMatch(RegexPatternHelper.GenerateProjectRegexPattern("OtherTestProject", TestingConstants.Passed, true, configuration), result.StdOut);
@@ -83,7 +83,7 @@ public void RunWithSolutionFilterPathInOtherDirectory_ShouldReturnExitCodeGeneri
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory($"{testInstance.Path}{Path.DirectorySeparatorChar}SolutionFilter")
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Failed, true, configuration), result.StdOut);
             Assert.DoesNotMatch(RegexPatternHelper.GenerateProjectRegexPattern("OtherTestProject", TestingConstants.Passed, true, configuration), result.StdOut);
@@ -102,8 +102,8 @@ public void RunWithInvalidProjectExtension_ShouldReturnExitCodeGenericFailure(st
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, invalidProjectPath,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--project", invalidProjectPath,
+                                             "--configuration", configuration);
 
             result.StdErr.Should().Contain(string.Format(CliCommandStrings.CmdInvalidProjectFileExtensionErrorDescription, invalidProjectPath));
 
@@ -121,8 +121,8 @@ public void RunWithDirectoryAsProjectOrSolutionOption_ShouldReturnExitCodeGeneri
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, projectPath,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--project", projectPath,
+                                             "--configuration", configuration);
 
             // Validate that only TestProject ran
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Failed, true, configuration), result.StdOut);
@@ -142,8 +142,8 @@ public void RunWithInvalidSolutionExtension_ShouldReturnExitCodeGenericFailure(s
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.SolutionOption.Name, invalidSolutionPath,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--solution", invalidSolutionPath,
+                                             "--configuration", configuration);
 
             result.StdErr.Should().Contain(string.Format(CliCommandStrings.CmdInvalidSolutionFileExtensionErrorDescription, invalidSolutionPath));
 
@@ -162,9 +162,9 @@ public void RunWithBothProjectAndSolutionOptions_ShouldReturnExitCodeGenericFail
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, testProjectPath,
-                                             MicrosoftTestingPlatformOptions.SolutionOption.Name, testSolutionPath,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--project", testProjectPath,
+                                             "--solution", testSolutionPath,
+                                             "--configuration", configuration);
 
             result.StdErr.Should().Contain(CliCommandStrings.CmdMultipleBuildPathOptionsErrorDescription);
 
@@ -182,8 +182,8 @@ public void RunWithNonExistentProjectPath_ShouldReturnExitCodeGenericFailure(str
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, testProjectPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--project", testProjectPath,
+                                    "--configuration", configuration);
 
             string fullProjectPath = $"{testInstance.TestRoot}{Path.DirectorySeparatorChar}{testProjectPath}";
             result.StdErr.Should().Contain(string.Format(CliCommandStrings.CmdNonExistentFileErrorDescription, fullProjectPath));
@@ -202,8 +202,8 @@ public void RunWithNonExistentSolutionPath_ShouldReturnExitCodeGenericFailure(st
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.SolutionOption.Name, solutionPath,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--solution", solutionPath,
+                                             "--configuration", configuration);
 
             string fullSolutionPath = $"{testInstance.TestRoot}{Path.DirectorySeparatorChar}{solutionPath}";
             result.StdErr.Should().Contain(string.Format(CliCommandStrings.CmdNonExistentFileErrorDescription, fullSolutionPath));
@@ -221,8 +221,8 @@ public void RunTestProjectWithArchOption_ShouldReturnExitCodeSuccess(string conf
             var arch = RuntimeInformation.ProcessArchitecture.Equals(Architecture.Arm64) ? "arm64" : Environment.Is64BitOperatingSystem ? "x64" : "x86";
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.ArchitectureOption.Name, arch,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--arch", arch,
+                                             "--configuration", configuration);
 
             string runtime = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
 
@@ -241,8 +241,8 @@ public void RunTestProjectSolutionWithArchOption_NotSupported(string configurati
             var arch = RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant();
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.ArchitectureOption.Name, arch,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--arch", arch,
+                                             "--configuration", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -270,7 +270,7 @@ public void RunTestProjectSolutionWithRuntimeOption_ShouldReturnExitCodeSuccess(
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(CommonOptions.RuntimeOptionName, runtime,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                             "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -290,8 +290,8 @@ public void RunTestProjectSolutionWithArchAndRuntimeOptions_ShouldReturnExitCode
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(CommonOptions.RuntimeOptionName, runtime,
-                                            CommonOptions.ArchitectureOption.Name, arch,
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                            "--arch", arch,
+                                            "--configuration", configuration);
 
             result.ExitCode.Should().Be(ExitCodes.GenericFailure);
         }
@@ -308,7 +308,7 @@ public void RunTestProjectSolutionWithOSOption_ShouldReturnExitCodeSuccess(strin
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(CommonOptions.OperatingSystemOption.Name, runtime.Split('-')[0],
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                            "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -328,8 +328,8 @@ public void RunTestProjectSolutionWithArchAndOSOptions_ShouldReturnExitCodeSucce
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(CommonOptions.OperatingSystemOption.Name, runtime.Split('-')[0],
-                                            CommonOptions.ArchitectureOption.Name, arch,
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                            "--arch", arch,
+                                            "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -352,10 +352,10 @@ public void RunSpecificCSProjRunsWithNoBuildAndNoRestoreOptions_ShouldReturnExit
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, "TestProject.csproj",
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration,
-                                            CommonOptions.NoRestoreOption.Name,
-                                            MicrosoftTestingPlatformOptions.NoBuildOption.Name);
+                                    .Execute("--project", "TestProject.csproj",
+                                            "--configuration", configuration,
+                                            "--no-restore",
+                                            "--no-build");
 
             // Assert that the bin folder hasn't been modified
             Assert.Equal(binDirectoryLastWriteTime, binDirectory?.LastWriteTime);
@@ -372,7 +372,7 @@ public void RunTestProjectSolutionWithBinLogOption_ShouldReturnExitCodeSuccess(s
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute("-bl", TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-bl", "--configuration", configuration);
 
             Assert.True(File.Exists(string.Format("{0}{1}{2}", testInstance.TestRoot, Path.DirectorySeparatorChar, CliConstants.BinLogFileName)));
 
@@ -388,8 +388,8 @@ public void RunSpecificCSProjRunsWithMSBuildArgs_ShouldReturnExitCodeSuccess(str
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption.Name, "TestProject.csproj",
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                    .Execute("--project", "TestProject.csproj",
+                                            "--configuration", configuration,
                                             "--property:WarningLevel=2", $"--property:Configuration={configuration}");
 
             if (!TestContext.IsLocalized())
@@ -414,7 +414,7 @@ public void RunOnSolutionWithMSBuildArgs_ShouldReturnExitCodeGenericFailure(stri
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                    .Execute("--configuration", configuration,
                                             "--property:WarningLevel=2");
 
             if (!TestContext.IsLocalized())
@@ -439,8 +439,8 @@ public void RunTestProjectSolutionWithFrameworkOption_ShouldReturnExitCodeSucces
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.FrameworkOption.Name, ToolsetInfo.CurrentTargetFramework,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--framework", ToolsetInfo.CurrentTargetFramework,
+                                             "--configuration", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -473,8 +473,8 @@ public void RunMultiTFMsProjectSolutionWithPreviousFramework_ShouldReturnExitCod
             // Restore then fails for OtherTestProject, and we run nothing.
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.FrameworkOption.Name, DotnetVersionHelper.GetPreviousDotnetVersion(),
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--framework", DotnetVersionHelper.GetPreviousDotnetVersion(),
+                                             "--configuration", configuration);
 
             // Output looks similar to the following
             /*
@@ -511,8 +511,8 @@ public void RunMultiTFMsProjectSolutionWithCurrentFramework_ShouldReturnExitCode
             // In total, 2 passing, 2 skipped, 4 failing
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.FrameworkOption.Name, ToolsetInfo.CurrentTargetFramework,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--framework", ToolsetInfo.CurrentTargetFramework,
+                                             "--configuration", configuration);
 
             if (!TestContext.IsLocalized())
             {
@@ -542,7 +542,7 @@ public void RunWithTraceFileLogging_ShouldReturnExitCodeGenericFailure(string co
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .WithEnvironmentVariable(CliConstants.TestTraceLoggingEnvVar, traceFile)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--configuration", configuration);
 
             Assert.True(File.Exists(Path.Combine(testInstance.Path, traceFile)), "Trace file should exist after test execution.");
 
@@ -560,7 +560,7 @@ public void RunWithTraceFileLoggingAndNonExistingDirectory_ShouldReturnExitCodeG
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .WithEnvironmentVariable(CliConstants.TestTraceLoggingEnvVar, traceFile)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--configuration", configuration);
 
             Assert.True(File.Exists(Path.Combine(testInstance.Path, traceFile)), "Trace file should exist after test execution.");
 
@@ -578,8 +578,8 @@ public void RunWithSolutionFilterContainingSharedProject_ShouldSkipSharedProject
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.SolutionOption.Name, testSolutionFilterPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--solution", testSolutionFilterPath,
+                                    "--configuration", configuration);
 
             // Validate that TestProject ran (shared project should be skipped automatically)
             result.StdOut.Should().Contain("TestProject.dll");
@@ -601,8 +601,8 @@ public void RunWithSolutionAndPlatformConfiguration_ShouldRespectPlatform(string
             // Test with "NonWindows" platform - OtherTestProject should NOT be included
             CommandResult resultX86 = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.SolutionOption.Name, testSolutionPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                    .Execute("--solution", testSolutionPath,
+                                    "--configuration", configuration,
                                     "--property:Platform=NonWindows");
 
             // Validate that TestProject ran but OtherTestProject did not (not marked for build on x86)
@@ -614,8 +614,8 @@ public void RunWithSolutionAndPlatformConfiguration_ShouldRespectPlatform(string
             // Test with x64 platform - both projects should be included
             CommandResult resultX64 = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(MicrosoftTestingPlatformOptions.SolutionOption.Name, testSolutionPath,
-                                    TestCommandDefinition.ConfigurationOption.Name, configuration,
+                                    .Execute("--solution", testSolutionPath,
+                                    "--configuration", configuration,
                                     "--property:Platform=x64");
 
             // Validate that both TestProject and OtherTestProject ran
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestRunsConsoleAppWithoutHandshake.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestRunsConsoleAppWithoutHandshake.cs
index 239c7dd76273..7b736adaa366 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestRunsConsoleAppWithoutHandshake.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestRunsConsoleAppWithoutHandshake.cs
@@ -25,7 +25,7 @@ public void RunConsoleAppDoesNothing_ShouldReturnCorrectExitCode(string configur
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("-c", configuration);
 
             result.ExitCode.Should().Be(ExitCodes.GenericFailure, "dotnet test should fail with a meaningful error when run against console app without MTP handshake");
         }

From 1d37f204f62e77280c3e1ef301c9f2466369f858 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 10:06:06 -0800
Subject: [PATCH 10/20] Inline test options

---
 .../MTP/MicrosoftTestingPlatformOptions.cs    | 124 --------
 .../dotnet/Commands/Test/MTP/OutputOptions.cs |  10 +
 .../Commands/Test/MTP/TestApplication.cs      |   8 +-
 .../Commands/Test/TestCommandDefinition.cs    | 290 +++++++++++++++---
 .../Commands/Test/VSTest/VSTestOptions.cs     | 138 +--------
 5 files changed, 269 insertions(+), 301 deletions(-)
 delete mode 100644 src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
 create mode 100644 src/Cli/dotnet/Commands/Test/MTP/OutputOptions.cs

diff --git a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs b/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
deleted file mode 100644
index 9caf500c2210..000000000000
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
+++ /dev/null
@@ -1,124 +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.CommandLine;
-
-namespace Microsoft.DotNet.Cli.Commands.Test;
-
-internal static class MicrosoftTestingPlatformOptions
-{
-    public static readonly Option<string> ProjectOrSolutionOption = new("--project")
-    {
-        Description = CliCommandStrings.CmdProjectOrSolutionDescriptionFormat,
-        HelpName = CliCommandStrings.CmdProjectOrSolutionPathName,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public static readonly Option<string> SolutionOption = new("--solution")
-    {
-        Description = CliCommandStrings.CmdSolutionDescription,
-        HelpName = CliCommandStrings.CmdSolutionPathName,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public static readonly Option<string> TestModulesFilterOption = new("--test-modules")
-    {
-        Description = CliCommandStrings.CmdTestModulesDescription,
-        HelpName = CliCommandStrings.CmdExpressionName
-    };
-
-    public static readonly Option<string> TestModulesRootDirectoryOption = new("--root-directory")
-    {
-        Description = CliCommandStrings.CmdTestModulesRootDirectoryDescription,
-        HelpName = CliCommandStrings.CmdRootPathName,
-    };
-
-    public const string ResultsDirectoryOptionName = "--results-directory";
-
-    public static readonly Option<string> ResultsDirectoryOption = new(ResultsDirectoryOptionName)
-    {
-        Description = CliCommandStrings.CmdResultsDirectoryDescription,
-        HelpName = CliCommandStrings.CmdPathToResultsDirectory,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public const string ConfigFileOptionName = "--config-file";
-
-    public static readonly Option<string> ConfigFileOption = new(ConfigFileOptionName)
-    {
-        Description = CliCommandStrings.CmdConfigFileDescription,
-        HelpName = CliCommandStrings.CmdConfigFilePath,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public const string DiagnosticOutputDirectoryOptionName = "--diagnostic-output-directory";
-
-    public static readonly Option<string> DiagnosticOutputDirectoryOption = new(DiagnosticOutputDirectoryOptionName)
-    {
-        Description = CliCommandStrings.CmdDiagnosticOutputDirectoryDescription,
-        HelpName = CliCommandStrings.CmdDiagnosticOutputDirectoryPath,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public static readonly Option<int> MaxParallelTestModulesOption = new("--max-parallel-test-modules")
-    {
-        Description = CliCommandStrings.CmdMaxParallelTestModulesDescription,
-        HelpName = CliCommandStrings.CmdNumberName
-    };
-
-    public static readonly Option<int> MinimumExpectedTestsOption = new("--minimum-expected-tests")
-    {
-        Description = CliCommandStrings.CmdMinimumExpectedTestsDescription,
-        HelpName = CliCommandStrings.CmdNumberName
-    };
-
-    public static readonly Option<bool> NoBuildOption = new("--no-build")
-    {
-        Description = CliCommandStrings.CmdNoBuildDescription
-    };
-
-    public static readonly Option<bool> NoAnsiOption = new("--no-ansi")
-    {
-        Description = CliCommandStrings.CmdNoAnsiDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
-    {
-        Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
-    {
-        Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
-    };
-
-    public static readonly Option<bool> NoProgressOption = new("--no-progress")
-    {
-        Description = CliCommandStrings.CmdNoProgressDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<OutputOptions> OutputOption = new("--output")
-    {
-        Description = CliCommandStrings.CmdTestOutputDescription,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public const string ListTestsOptionName = "--list-tests";
-
-    public static readonly Option<string> ListTestsOption = new(ListTestsOptionName)
-    {
-        Description = CliCommandStrings.CmdListTestsDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<string[]> MTPTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget);
-}
-
-internal enum OutputOptions
-{
-    Normal,
-    Detailed
-}
diff --git a/src/Cli/dotnet/Commands/Test/MTP/OutputOptions.cs b/src/Cli/dotnet/Commands/Test/MTP/OutputOptions.cs
new file mode 100644
index 000000000000..2c2077fa6c7d
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Test/MTP/OutputOptions.cs
@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Cli.Commands.Test;
+
+internal enum OutputOptions
+{
+    Normal,
+    Detailed
+}
diff --git a/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs b/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs
index 17ecdccfb98a..fb37be9fea9b 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/TestApplication.cs
@@ -150,22 +150,22 @@ private string GetArguments()
 
         if (TestOptions.IsDiscovery)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ListTestsOptionName}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.ListTestsOptionName}");
         }
 
         if (_buildOptions.PathOptions.ResultsDirectoryPath is { } resultsDirectoryPath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ResultsDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.ResultsDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
         }
 
         if (_buildOptions.PathOptions.ConfigFilePath is { } configFilePath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ConfigFileOptionName} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.ConfigFileOptionName} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
         }
 
         if (_buildOptions.PathOptions.DiagnosticOutputDirectoryPath is { } diagnosticOutputDirectoryPath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(diagnosticOutputDirectoryPath)}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.DiagnosticOutputDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(diagnosticOutputDirectoryPath)}");
         }
 
         foreach (var arg in _buildOptions.UnmatchedTokens)
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index d3142439b5d5..5514e9793798 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -6,6 +6,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.TemplateEngine.Cli.Commands;
 using Microsoft.TemplateEngine.Cli.Help;
 using Command = System.CommandLine.Command;
@@ -94,29 +95,126 @@ private sealed class GlobalJsonTestNode
 
     public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHelp
     {
-        public readonly Option<string> ProjectOrSolutionOption = MicrosoftTestingPlatformOptions.ProjectOrSolutionOption;
-        public readonly Option<string> SolutionOption = MicrosoftTestingPlatformOptions.SolutionOption;
-        public readonly Option<string> TestModulesFilterOption = MicrosoftTestingPlatformOptions.TestModulesFilterOption;
-        public readonly Option<string> TestModulesRootDirectoryOption = MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption;
-        public readonly Option<string> ResultsDirectoryOption = MicrosoftTestingPlatformOptions.ResultsDirectoryOption;
-        public readonly Option<string> ConfigFileOption = MicrosoftTestingPlatformOptions.ConfigFileOption;
-        public readonly Option<string> DiagnosticOutputDirectoryOption = MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption;
-        public readonly Option<int> MaxParallelTestModulesOption = MicrosoftTestingPlatformOptions.MaxParallelTestModulesOption;
-        public readonly Option<int> MinimumExpectedTestsOption = MicrosoftTestingPlatformOptions.MinimumExpectedTestsOption;
+        public readonly Option<string> ProjectOrSolutionOption = new("--project")
+        {
+            Description = CliCommandStrings.CmdProjectOrSolutionDescriptionFormat,
+            HelpName = CliCommandStrings.CmdProjectOrSolutionPathName,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public readonly Option<string> SolutionOption = new("--solution")
+        {
+            Description = CliCommandStrings.CmdSolutionDescription,
+            HelpName = CliCommandStrings.CmdSolutionPathName,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public readonly Option<string> TestModulesFilterOption = new("--test-modules")
+        {
+            Description = CliCommandStrings.CmdTestModulesDescription,
+            HelpName = CliCommandStrings.CmdExpressionName
+        };
+
+        public readonly Option<string> TestModulesRootDirectoryOption = new("--root-directory")
+        {
+            Description = CliCommandStrings.CmdTestModulesRootDirectoryDescription,
+            HelpName = CliCommandStrings.CmdRootPathName,
+        };
+
+        public const string ResultsDirectoryOptionName = "--results-directory";
+
+        public readonly Option<string> ResultsDirectoryOption = new(ResultsDirectoryOptionName)
+        {
+            Description = CliCommandStrings.CmdResultsDirectoryDescription,
+            HelpName = CliCommandStrings.CmdPathToResultsDirectory,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public const string ConfigFileOptionName = "--config-file";
+
+        public readonly Option<string> ConfigFileOption = new(ConfigFileOptionName)
+        {
+            Description = CliCommandStrings.CmdConfigFileDescription,
+            HelpName = CliCommandStrings.CmdConfigFilePath,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public const string DiagnosticOutputDirectoryOptionName = "--diagnostic-output-directory";
+
+        public readonly Option<string> DiagnosticOutputDirectoryOption = new(DiagnosticOutputDirectoryOptionName)
+        {
+            Description = CliCommandStrings.CmdDiagnosticOutputDirectoryDescription,
+            HelpName = CliCommandStrings.CmdDiagnosticOutputDirectoryPath,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public readonly Option<int> MaxParallelTestModulesOption = new("--max-parallel-test-modules")
+        {
+            Description = CliCommandStrings.CmdMaxParallelTestModulesDescription,
+            HelpName = CliCommandStrings.CmdNumberName
+        };
+
+        public readonly Option<int> MinimumExpectedTestsOption = new("--minimum-expected-tests")
+        {
+            Description = CliCommandStrings.CmdMinimumExpectedTestsDescription,
+            HelpName = CliCommandStrings.CmdNumberName
+        };
+
         public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+
         public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
+
         public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+
         public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+
         public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+
         public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-        public readonly Option<bool> NoBuildOption = MicrosoftTestingPlatformOptions.NoBuildOption;
-        public readonly Option<bool> NoAnsiOption = MicrosoftTestingPlatformOptions.NoAnsiOption;
-        public readonly Option<bool> NoProgressOption = MicrosoftTestingPlatformOptions.NoProgressOption;
-        public readonly Option<OutputOptions> OutputOption = MicrosoftTestingPlatformOptions.OutputOption;
-        public readonly Option<string> ListTestsOption = MicrosoftTestingPlatformOptions.ListTestsOption;
-        public readonly Option<bool> NoLaunchProfileOption = MicrosoftTestingPlatformOptions.NoLaunchProfileOption;
-        public readonly Option<bool> NoLaunchProfileArgumentsOption = MicrosoftTestingPlatformOptions.NoLaunchProfileArgumentsOption;
-        public readonly Option<string[]> MTPTargetOption = MicrosoftTestingPlatformOptions.MTPTargetOption;
+
+        public readonly Option<bool> NoBuildOption = new("--no-build")
+        {
+            Description = CliCommandStrings.CmdNoBuildDescription
+        };
+
+        public readonly Option<bool> NoAnsiOption = new("--no-ansi")
+        {
+            Description = CliCommandStrings.CmdNoAnsiDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<bool> NoProgressOption = new("--no-progress")
+        {
+            Description = CliCommandStrings.CmdNoProgressDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<OutputOptions> OutputOption = new("--output")
+        {
+            Description = CliCommandStrings.CmdTestOutputDescription,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public const string ListTestsOptionName = "--list-tests";
+
+        public readonly Option<string> ListTestsOption = new(ListTestsOptionName)
+        {
+            Description = CliCommandStrings.CmdListTestsDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
+        {
+            Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
+        {
+            Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
+        };
+
+        public readonly Option<string[]> MTPTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget);
 
         public ICustomHelp? CustomHelpLayoutProvider { get; set; }
 
@@ -157,34 +255,154 @@ public IEnumerable<Action<HelpContext>> CustomHelpLayout()
 
     public sealed class VSTest : TestCommandDefinition
     {
-        public readonly Option<string> SettingsOption = VSTestOptions.SettingsOption;
-        public readonly Option<bool> ListTestsOption = VSTestOptions.ListTestsOption;
+        public readonly Option<string> SettingsOption = new Option<string>("--settings", "-s")
+        {
+            Description = CliCommandStrings.CmdSettingsDescription,
+            HelpName = CliCommandStrings.CmdSettingsFile
+        }.ForwardAsSingle(o => $"-property:VSTestSetting={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
+
+        public readonly Option<bool> ListTestsOption = new Option<bool>("--list-tests", "-t")
+        {
+            Description = CliCommandStrings.CmdListTestsDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:VSTestListTests=true");
+
         public readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
-        public readonly Option<string> FilterOption = VSTestOptions.FilterOption;
-        public readonly Option<IEnumerable<string>> AdapterOption = VSTestOptions.AdapterOption;
-        public readonly Option<IEnumerable<string>> LoggerOption = VSTestOptions.LoggerOption;
-        public readonly Option<string> OutputOption = VSTestOptions.OutputOption;
+
+        public readonly Option<string> FilterOption = new Option<string>("--filter")
+        {
+            Description = CliCommandStrings.CmdTestCaseFilterDescription,
+            HelpName = CliCommandStrings.CmdTestCaseFilterExpression
+        }.ForwardAsSingle(o => $"-property:VSTestTestCaseFilter={VSTestOptions.SurroundWithDoubleQuotes(o!)}");
+
+        public readonly Option<IEnumerable<string>> AdapterOption = new Option<IEnumerable<string>>("--test-adapter-path")
+        {
+            Description = CliCommandStrings.CmdTestAdapterPathDescription,
+            HelpName = CliCommandStrings.CmdTestAdapterPath
+        }.ForwardAsSingle(o => $"-property:VSTestTestAdapterPath={VSTestOptions.SurroundWithDoubleQuotes(string.Join(";", o!.Select(CommandDirectoryContext.GetFullPath)))}")
+        .AllowSingleArgPerToken();
+
+        public readonly Option<IEnumerable<string>> LoggerOption = new Option<IEnumerable<string>>("--logger", "-l")
+        {
+            Description = CliCommandStrings.CmdLoggerDescription,
+            HelpName = CliCommandStrings.CmdLoggerOption
+        }.ForwardAsSingle(o =>
+        {
+            var loggersString = string.Join(";", VSTestOptions.GetSemiColonEscapedArgs(o!));
+            return $"-property:VSTestLogger={VSTestOptions.SurroundWithDoubleQuotes(loggersString)}";
+        })
+        .AllowSingleArgPerToken();
+
+        public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+        {
+            Description = CliCommandStrings.CmdOutputDescription,
+            HelpName = CliCommandStrings.TestCmdOutputDir
+        }
+        .ForwardAsOutputPath("OutputPath", true);
+
         public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-        public readonly Option<string> DiagOption = VSTestOptions.DiagOption;
-        public readonly Option<bool> NoBuildOption = VSTestOptions.NoBuildOption;
-        public readonly Option<string> ResultsOption = VSTestOptions.ResultsOption;
-        public readonly Option<IEnumerable<string>> CollectOption = VSTestOptions.CollectOption;
-        public readonly Option<bool> BlameOption = VSTestOptions.BlameOption;
-        public readonly Option<bool> BlameCrashOption = VSTestOptions.BlameCrashOption;
-        public readonly Option<string> BlameCrashDumpOption = VSTestOptions.BlameCrashDumpOption;
-        public readonly Option<bool> BlameCrashAlwaysOption = VSTestOptions.BlameCrashAlwaysOption;
-        public readonly Option<bool> BlameHangOption = VSTestOptions.BlameHangOption;
-        public readonly Option<string> BlameHangDumpOption = VSTestOptions.BlameHangDumpOption;
-        public readonly Option<string> BlameHangTimeoutOption = VSTestOptions.BlameHangTimeoutOption;
-        public readonly Option<bool> NoLogoOption = VSTestOptions.NoLogoOption;
+
+        public readonly Option<string> DiagOption = new Option<string>("--diag", "-d")
+        {
+            Description = CliCommandStrings.CmdPathTologFileDescription,
+            HelpName = CliCommandStrings.CmdPathToLogFile
+        }
+        .ForwardAsSingle(o => $"-property:VSTestDiag={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
+
+        public readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
+        {
+            Description = CliCommandStrings.CmdNoBuildDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:VSTestNoBuild=true");
+
+        public readonly Option<string> ResultsOption = new Option<string>("--results-directory")
+        {
+            Description = CliCommandStrings.CmdResultsDirectoryDescription,
+            HelpName = CliCommandStrings.CmdPathToResultsDirectory
+        }.ForwardAsSingle(o => $"-property:VSTestResultsDirectory={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
+
+        public readonly Option<IEnumerable<string>> CollectOption = new Option<IEnumerable<string>>("--collect")
+        {
+            Description = CliCommandStrings.cmdCollectDescription,
+            HelpName = CliCommandStrings.cmdCollectFriendlyName
+        }.ForwardAsSingle(o => $"-property:VSTestCollect=\"{string.Join(";", VSTestOptions.GetSemiColonEscapedArgs(o!))}\"")
+        .AllowSingleArgPerToken();
+
+        public readonly Option<bool> BlameOption = new Option<bool>("--blame")
+        {
+            Description = CliCommandStrings.CmdBlameDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardIfEnabled("-property:VSTestBlame=true");
+
+        public readonly Option<bool> BlameCrashOption = new Option<bool>("--blame-crash")
+        {
+            Description = CliCommandStrings.CmdBlameCrashDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardIfEnabled("-property:VSTestBlameCrash=true");
+
+        public readonly Option<string> BlameCrashDumpOption = CreateBlameCrashDumpOption();
+
+        public readonly Option<bool> BlameCrashAlwaysOption = new Option<bool>("--blame-crash-collect-always")
+        {
+            Description = CliCommandStrings.CmdBlameCrashCollectAlwaysDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardIfEnabled(["-property:VSTestBlameCrash=true", "-property:VSTestBlameCrashCollectAlways=true"]);
+
+        public readonly Option<bool> BlameHangOption = new Option<bool>("--blame-hang")
+        {
+            Description = CliCommandStrings.CmdBlameHangDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:VSTestBlameHang=true");
+
+        public readonly Option<string> BlameHangDumpOption = CreateBlameHangDumpOption();
+
+        public readonly Option<string> BlameHangTimeoutOption = new Option<string>("--blame-hang-timeout")
+        {
+            Description = CliCommandStrings.CmdBlameHangTimeoutDescription,
+            HelpName = CliCommandStrings.HangTimeoutArgumentName
+        }.ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangTimeout={o}"]);
+
+        public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
+
         public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+
         public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
         public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+
         public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+
         public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+
         public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+
         public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-        public readonly Option<string[]> VsTestTargetOption = VSTestOptions.VsTestTargetOption;
+
+        public readonly Option<string[]> VsTestTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("VSTest");
+
+        private static Option<string> CreateBlameCrashDumpOption()
+        {
+            Option<string> result = new Option<string>("--blame-crash-dump-type")
+            {
+                Description = CliCommandStrings.CmdBlameCrashDumpTypeDescription,
+                HelpName = CliCommandStrings.CrashDumpTypeArgumentName,
+            }
+            .ForwardAsMany(o => ["-property:VSTestBlameCrash=true", $"-property:VSTestBlameCrashDumpType={o}"]);
+            result.AcceptOnlyFromAmong(["full", "mini"]);
+            return result;
+        }
+
+        private static Option<string> CreateBlameHangDumpOption()
+        {
+            Option<string> result = new Option<string>("--blame-hang-dump-type")
+            {
+                Description = CliCommandStrings.CmdBlameHangDumpTypeDescription,
+                HelpName = CliCommandStrings.HangDumpTypeArgumentName
+            }
+            .ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangDumpType={o}"]);
+            result.AcceptOnlyFromAmong(["full", "mini", "none"]);
+            return result;
+        }
 
         public VSTest()
             : base(CliCommandStrings.DotnetTestCommandVSTestDescription)
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs b/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
index 21c4cd8ef510..6fbac1b98f85 100644
--- a/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
+++ b/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
@@ -1,146 +1,10 @@
 // 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 Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Extensions;
-
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal static class VSTestOptions
 {
-    public static readonly Option<string> SettingsOption = new Option<string>("--settings", "-s")
-    {
-        Description = CliCommandStrings.CmdSettingsDescription,
-        HelpName = CliCommandStrings.CmdSettingsFile
-    }.ForwardAsSingle(o => $"-property:VSTestSetting={SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
-
-    public static readonly Option<bool> ListTestsOption = new Option<bool>("--list-tests", "-t")
-    {
-        Description = CliCommandStrings.CmdListTestsDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:VSTestListTests=true");
-
-    public static readonly Option<string> FilterOption = new Option<string>("--filter")
-    {
-        Description = CliCommandStrings.CmdTestCaseFilterDescription,
-        HelpName = CliCommandStrings.CmdTestCaseFilterExpression
-    }.ForwardAsSingle(o => $"-property:VSTestTestCaseFilter={SurroundWithDoubleQuotes(o!)}");
-
-    public static readonly Option<IEnumerable<string>> AdapterOption = new Option<IEnumerable<string>>("--test-adapter-path")
-    {
-        Description = CliCommandStrings.CmdTestAdapterPathDescription,
-        HelpName = CliCommandStrings.CmdTestAdapterPath
-    }.ForwardAsSingle(o => $"-property:VSTestTestAdapterPath={SurroundWithDoubleQuotes(string.Join(";", o!.Select(CommandDirectoryContext.GetFullPath)))}")
-    .AllowSingleArgPerToken();
-
-    public static readonly Option<IEnumerable<string>> LoggerOption = new Option<IEnumerable<string>>("--logger", "-l")
-    {
-        Description = CliCommandStrings.CmdLoggerDescription,
-        HelpName = CliCommandStrings.CmdLoggerOption
-    }.ForwardAsSingle(o =>
-    {
-        var loggersString = string.Join(";", GetSemiColonEscapedArgs(o!));
-
-        return $"-property:VSTestLogger={SurroundWithDoubleQuotes(loggersString)}";
-    })
-    .AllowSingleArgPerToken();
-
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-    {
-        Description = CliCommandStrings.CmdOutputDescription,
-        HelpName = CliCommandStrings.TestCmdOutputDir
-    }
-    .ForwardAsOutputPath("OutputPath", true);
-
-    public static readonly Option<string> DiagOption = new Option<string>("--diag", "-d")
-    {
-        Description = CliCommandStrings.CmdPathTologFileDescription,
-        HelpName = CliCommandStrings.CmdPathToLogFile
-    }
-    .ForwardAsSingle(o => $"-property:VSTestDiag={SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
-
-    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
-    {
-        Description = CliCommandStrings.CmdNoBuildDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:VSTestNoBuild=true");
-
-    public static readonly Option<string> ResultsOption = new Option<string>("--results-directory")
-    {
-        Description = CliCommandStrings.CmdResultsDirectoryDescription,
-        HelpName = CliCommandStrings.CmdPathToResultsDirectory
-    }.ForwardAsSingle(o => $"-property:VSTestResultsDirectory={SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
-
-    public static readonly Option<IEnumerable<string>> CollectOption = new Option<IEnumerable<string>>("--collect")
-    {
-        Description = CliCommandStrings.cmdCollectDescription,
-        HelpName = CliCommandStrings.cmdCollectFriendlyName
-    }.ForwardAsSingle(o => $"-property:VSTestCollect=\"{string.Join(";", GetSemiColonEscapedArgs(o!))}\"")
-    .AllowSingleArgPerToken();
-
-    public static readonly Option<bool> BlameOption = new Option<bool>("--blame")
-    {
-        Description = CliCommandStrings.CmdBlameDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardIfEnabled("-property:VSTestBlame=true");
-
-    public static readonly Option<bool> BlameCrashOption = new Option<bool>("--blame-crash")
-    {
-        Description = CliCommandStrings.CmdBlameCrashDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardIfEnabled("-property:VSTestBlameCrash=true");
-
-    public static readonly Option<string> BlameCrashDumpOption = CreateBlameCrashDumpOption();
-
-    private static Option<string> CreateBlameCrashDumpOption()
-    {
-        Option<string> result = new Option<string>("--blame-crash-dump-type")
-        {
-            Description = CliCommandStrings.CmdBlameCrashDumpTypeDescription,
-            HelpName = CliCommandStrings.CrashDumpTypeArgumentName,
-        }
-        .ForwardAsMany(o => ["-property:VSTestBlameCrash=true", $"-property:VSTestBlameCrashDumpType={o}"]);
-        result.AcceptOnlyFromAmong(["full", "mini"]);
-        return result;
-    }
-
-    public static readonly Option<bool> BlameCrashAlwaysOption = new Option<bool>("--blame-crash-collect-always")
-    {
-        Description = CliCommandStrings.CmdBlameCrashCollectAlwaysDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardIfEnabled(["-property:VSTestBlameCrash=true", "-property:VSTestBlameCrashCollectAlways=true"]);
-
-    public static readonly Option<bool> BlameHangOption = new Option<bool>("--blame-hang")
-    {
-        Description = CliCommandStrings.CmdBlameHangDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:VSTestBlameHang=true");
-
-    public static readonly Option<string> BlameHangDumpOption = CreateBlameHangDumpOption();
-
-    private static Option<string> CreateBlameHangDumpOption()
-    {
-        Option<string> result = new Option<string>("--blame-hang-dump-type")
-        {
-            Description = CliCommandStrings.CmdBlameHangDumpTypeDescription,
-            HelpName = CliCommandStrings.HangDumpTypeArgumentName
-        }
-        .ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangDumpType={o}"]);
-        result.AcceptOnlyFromAmong(["full", "mini", "none"]);
-        return result;
-    }
-
-    public static readonly Option<string> BlameHangTimeoutOption = new Option<string>("--blame-hang-timeout")
-    {
-        Description = CliCommandStrings.CmdBlameHangTimeoutDescription,
-        HelpName = CliCommandStrings.HangTimeoutArgumentName
-    }.ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangTimeout={o}"]);
-
-    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
-
-    public static readonly Option<string[]> VsTestTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("VSTest");
-
     private static string GetSemiColonEscapedstring(string arg)
     {
         if (arg.IndexOf(";") != -1)
@@ -151,7 +15,7 @@ private static string GetSemiColonEscapedstring(string arg)
         return arg;
     }
 
-    private static string[] GetSemiColonEscapedArgs(IEnumerable<string> args)
+    internal static string[] GetSemiColonEscapedArgs(IEnumerable<string> args)
     {
         int counter = 0;
         string[] array = new string[args.Count()];

From 7025f254b4dde694d4e495d6967e6a579154a1d6 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 10:06:29 -0800
Subject: [PATCH 11/20] Split test def file

---
 ...mandDefinition.MicrosoftTestingPlatform.cs | 172 +++++++++
 .../Test/TestCommandDefinition.VSTest.cs      | 203 ++++++++++
 .../Commands/Test/TestCommandDefinition.cs    | 357 +-----------------
 3 files changed, 376 insertions(+), 356 deletions(-)
 create mode 100644 src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
 create mode 100644 src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs

diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
new file mode 100644
index 000000000000..7ebb96cfddd9
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
@@ -0,0 +1,172 @@
+// 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.ObjectModel;
+using System.CommandLine;
+using Microsoft.TemplateEngine.Cli.Commands;
+using Microsoft.TemplateEngine.Cli.Help;
+
+namespace Microsoft.DotNet.Cli.Commands.Test;
+
+internal abstract partial class TestCommandDefinition
+{
+    public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHelp
+    {
+        public readonly Option<string> ProjectOrSolutionOption = new("--project")
+        {
+            Description = CliCommandStrings.CmdProjectOrSolutionDescriptionFormat,
+            HelpName = CliCommandStrings.CmdProjectOrSolutionPathName,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public readonly Option<string> SolutionOption = new("--solution")
+        {
+            Description = CliCommandStrings.CmdSolutionDescription,
+            HelpName = CliCommandStrings.CmdSolutionPathName,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public readonly Option<string> TestModulesFilterOption = new("--test-modules")
+        {
+            Description = CliCommandStrings.CmdTestModulesDescription,
+            HelpName = CliCommandStrings.CmdExpressionName
+        };
+
+        public readonly Option<string> TestModulesRootDirectoryOption = new("--root-directory")
+        {
+            Description = CliCommandStrings.CmdTestModulesRootDirectoryDescription,
+            HelpName = CliCommandStrings.CmdRootPathName,
+        };
+
+        public const string ResultsDirectoryOptionName = "--results-directory";
+
+        public readonly Option<string> ResultsDirectoryOption = new(ResultsDirectoryOptionName)
+        {
+            Description = CliCommandStrings.CmdResultsDirectoryDescription,
+            HelpName = CliCommandStrings.CmdPathToResultsDirectory,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public const string ConfigFileOptionName = "--config-file";
+
+        public readonly Option<string> ConfigFileOption = new(ConfigFileOptionName)
+        {
+            Description = CliCommandStrings.CmdConfigFileDescription,
+            HelpName = CliCommandStrings.CmdConfigFilePath,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public const string DiagnosticOutputDirectoryOptionName = "--diagnostic-output-directory";
+
+        public readonly Option<string> DiagnosticOutputDirectoryOption = new(DiagnosticOutputDirectoryOptionName)
+        {
+            Description = CliCommandStrings.CmdDiagnosticOutputDirectoryDescription,
+            HelpName = CliCommandStrings.CmdDiagnosticOutputDirectoryPath,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public readonly Option<int> MaxParallelTestModulesOption = new("--max-parallel-test-modules")
+        {
+            Description = CliCommandStrings.CmdMaxParallelTestModulesDescription,
+            HelpName = CliCommandStrings.CmdNumberName
+        };
+
+        public readonly Option<int> MinimumExpectedTestsOption = new("--minimum-expected-tests")
+        {
+            Description = CliCommandStrings.CmdMinimumExpectedTestsDescription,
+            HelpName = CliCommandStrings.CmdNumberName
+        };
+
+        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+
+        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
+
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+
+        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+
+        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+
+        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+        public readonly Option<bool> NoBuildOption = new("--no-build")
+        {
+            Description = CliCommandStrings.CmdNoBuildDescription
+        };
+
+        public readonly Option<bool> NoAnsiOption = new("--no-ansi")
+        {
+            Description = CliCommandStrings.CmdNoAnsiDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<bool> NoProgressOption = new("--no-progress")
+        {
+            Description = CliCommandStrings.CmdNoProgressDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<OutputOptions> OutputOption = new("--output")
+        {
+            Description = CliCommandStrings.CmdTestOutputDescription,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        public const string ListTestsOptionName = "--list-tests";
+
+        public readonly Option<string> ListTestsOption = new(ListTestsOptionName)
+        {
+            Description = CliCommandStrings.CmdListTestsDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
+        {
+            Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
+            Arity = ArgumentArity.Zero
+        };
+
+        public readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
+        {
+            Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
+        };
+
+        public readonly Option<string[]> MTPTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget);
+
+        public ICustomHelp? CustomHelpLayoutProvider { get; set; }
+
+        public MicrosoftTestingPlatform()
+            : base(CliCommandStrings.DotnetTestCommandMTPDescription)
+        {
+            Options.Add(ProjectOrSolutionOption);
+            Options.Add(SolutionOption);
+            Options.Add(TestModulesFilterOption);
+            Options.Add(TestModulesRootDirectoryOption);
+            Options.Add(ResultsDirectoryOption);
+            Options.Add(ConfigFileOption);
+            Options.Add(DiagnosticOutputDirectoryOption);
+            Options.Add(MaxParallelTestModulesOption);
+            Options.Add(MinimumExpectedTestsOption);
+            Options.Add(ArchitectureOption);
+            Options.Add(EnvOption);
+            Options.Add(PropertiesOption);
+            Options.Add(ConfigurationOption);
+            Options.Add(FrameworkOption);
+            Options.Add(OperatingSystemOption);
+            Options.Add(RuntimeOption);
+            Options.Add(VerbosityOption);
+            Options.Add(NoRestoreOption);
+            Options.Add(NoBuildOption);
+            Options.Add(NoAnsiOption);
+            Options.Add(NoProgressOption);
+            Options.Add(OutputOption);
+            Options.Add(ListTestsOption);
+            Options.Add(NoLaunchProfileOption);
+            Options.Add(NoLaunchProfileArgumentsOption);
+            Options.Add(MTPTargetOption);
+        }
+
+        public IEnumerable<Action<HelpContext>> CustomHelpLayout()
+            => CustomHelpLayoutProvider?.CustomHelpLayout() ?? [];
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
new file mode 100644
index 000000000000..66c17c83348e
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
@@ -0,0 +1,203 @@
+// 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.ObjectModel;
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Extensions;
+
+namespace Microsoft.DotNet.Cli.Commands.Test;
+
+internal abstract partial class TestCommandDefinition
+{
+    public sealed class VSTest : TestCommandDefinition
+    {
+        public readonly Option<string> SettingsOption = new Option<string>("--settings", "-s")
+        {
+            Description = CliCommandStrings.CmdSettingsDescription,
+            HelpName = CliCommandStrings.CmdSettingsFile
+        }.ForwardAsSingle(o => $"-property:VSTestSetting={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
+
+        public readonly Option<bool> ListTestsOption = new Option<bool>("--list-tests", "-t")
+        {
+            Description = CliCommandStrings.CmdListTestsDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:VSTestListTests=true");
+
+        public readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
+
+        public readonly Option<string> FilterOption = new Option<string>("--filter")
+        {
+            Description = CliCommandStrings.CmdTestCaseFilterDescription,
+            HelpName = CliCommandStrings.CmdTestCaseFilterExpression
+        }.ForwardAsSingle(o => $"-property:VSTestTestCaseFilter={VSTestOptions.SurroundWithDoubleQuotes(o!)}");
+
+        public readonly Option<IEnumerable<string>> AdapterOption = new Option<IEnumerable<string>>("--test-adapter-path")
+        {
+            Description = CliCommandStrings.CmdTestAdapterPathDescription,
+            HelpName = CliCommandStrings.CmdTestAdapterPath
+        }.ForwardAsSingle(o => $"-property:VSTestTestAdapterPath={VSTestOptions.SurroundWithDoubleQuotes(string.Join(";", o!.Select(CommandDirectoryContext.GetFullPath)))}")
+        .AllowSingleArgPerToken();
+
+        public readonly Option<IEnumerable<string>> LoggerOption = new Option<IEnumerable<string>>("--logger", "-l")
+        {
+            Description = CliCommandStrings.CmdLoggerDescription,
+            HelpName = CliCommandStrings.CmdLoggerOption
+        }.ForwardAsSingle(o =>
+        {
+            var loggersString = string.Join(";", VSTestOptions.GetSemiColonEscapedArgs(o!));
+            return $"-property:VSTestLogger={VSTestOptions.SurroundWithDoubleQuotes(loggersString)}";
+        })
+        .AllowSingleArgPerToken();
+
+        public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+        {
+            Description = CliCommandStrings.CmdOutputDescription,
+            HelpName = CliCommandStrings.TestCmdOutputDir
+        }
+        .ForwardAsOutputPath("OutputPath", true);
+
+        public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+
+        public readonly Option<string> DiagOption = new Option<string>("--diag", "-d")
+        {
+            Description = CliCommandStrings.CmdPathTologFileDescription,
+            HelpName = CliCommandStrings.CmdPathToLogFile
+        }
+        .ForwardAsSingle(o => $"-property:VSTestDiag={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
+
+        public readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
+        {
+            Description = CliCommandStrings.CmdNoBuildDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:VSTestNoBuild=true");
+
+        public readonly Option<string> ResultsOption = new Option<string>("--results-directory")
+        {
+            Description = CliCommandStrings.CmdResultsDirectoryDescription,
+            HelpName = CliCommandStrings.CmdPathToResultsDirectory
+        }.ForwardAsSingle(o => $"-property:VSTestResultsDirectory={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
+
+        public readonly Option<IEnumerable<string>> CollectOption = new Option<IEnumerable<string>>("--collect")
+        {
+            Description = CliCommandStrings.cmdCollectDescription,
+            HelpName = CliCommandStrings.cmdCollectFriendlyName
+        }.ForwardAsSingle(o => $"-property:VSTestCollect=\"{string.Join(";", VSTestOptions.GetSemiColonEscapedArgs(o!))}\"")
+        .AllowSingleArgPerToken();
+
+        public readonly Option<bool> BlameOption = new Option<bool>("--blame")
+        {
+            Description = CliCommandStrings.CmdBlameDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardIfEnabled("-property:VSTestBlame=true");
+
+        public readonly Option<bool> BlameCrashOption = new Option<bool>("--blame-crash")
+        {
+            Description = CliCommandStrings.CmdBlameCrashDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardIfEnabled("-property:VSTestBlameCrash=true");
+
+        public readonly Option<string> BlameCrashDumpOption = CreateBlameCrashDumpOption();
+
+        public readonly Option<bool> BlameCrashAlwaysOption = new Option<bool>("--blame-crash-collect-always")
+        {
+            Description = CliCommandStrings.CmdBlameCrashCollectAlwaysDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardIfEnabled(["-property:VSTestBlameCrash=true", "-property:VSTestBlameCrashCollectAlways=true"]);
+
+        public readonly Option<bool> BlameHangOption = new Option<bool>("--blame-hang")
+        {
+            Description = CliCommandStrings.CmdBlameHangDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:VSTestBlameHang=true");
+
+        public readonly Option<string> BlameHangDumpOption = CreateBlameHangDumpOption();
+
+        public readonly Option<string> BlameHangTimeoutOption = new Option<string>("--blame-hang-timeout")
+        {
+            Description = CliCommandStrings.CmdBlameHangTimeoutDescription,
+            HelpName = CliCommandStrings.HangTimeoutArgumentName
+        }.ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangTimeout={o}"]);
+
+        public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
+
+        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
+
+        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+        public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+
+        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+
+        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+
+        public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+
+        public readonly Option<string[]> VsTestTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("VSTest");
+
+        private static Option<string> CreateBlameCrashDumpOption()
+        {
+            Option<string> result = new Option<string>("--blame-crash-dump-type")
+            {
+                Description = CliCommandStrings.CmdBlameCrashDumpTypeDescription,
+                HelpName = CliCommandStrings.CrashDumpTypeArgumentName,
+            }
+            .ForwardAsMany(o => ["-property:VSTestBlameCrash=true", $"-property:VSTestBlameCrashDumpType={o}"]);
+            result.AcceptOnlyFromAmong(["full", "mini"]);
+            return result;
+        }
+
+        private static Option<string> CreateBlameHangDumpOption()
+        {
+            Option<string> result = new Option<string>("--blame-hang-dump-type")
+            {
+                Description = CliCommandStrings.CmdBlameHangDumpTypeDescription,
+                HelpName = CliCommandStrings.HangDumpTypeArgumentName
+            }
+            .ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangDumpType={o}"]);
+            result.AcceptOnlyFromAmong(["full", "mini", "none"]);
+            return result;
+        }
+
+        public VSTest()
+            : base(CliCommandStrings.DotnetTestCommandVSTestDescription)
+        {
+            // We are on purpose not capturing the solution, project or directory here. We want to pass it to the
+            // MSBuild command so we are letting it flow.
+
+            Options.Add(SettingsOption);
+            Options.Add(ListTestsOption);
+            Options.Add(TestEnvOption);
+            Options.Add(FilterOption);
+            Options.Add(AdapterOption);
+            Options.Add(LoggerOption);
+            Options.Add(OutputOption);
+            Options.Add(ArtifactsPathOption);
+            Options.Add(DiagOption);
+            Options.Add(NoBuildOption);
+            Options.Add(ResultsOption);
+            Options.Add(CollectOption);
+            Options.Add(BlameOption);
+            Options.Add(BlameCrashOption);
+            Options.Add(BlameCrashDumpOption);
+            Options.Add(BlameCrashAlwaysOption);
+            Options.Add(BlameHangOption);
+            Options.Add(BlameHangDumpOption);
+            Options.Add(BlameHangTimeoutOption);
+            Options.Add(NoLogoOption);
+            Options.Add(ConfigurationOption);
+            Options.Add(FrameworkOption);
+            Options.Add(RuntimeOption);
+            Options.Add(NoRestoreOption);
+            Options.Add(InteractiveOption);
+            Options.Add(VerbosityOption);
+            Options.Add(ArchitectureOption);
+            Options.Add(OperatingSystemOption);
+            Options.Add(PropertiesOption);
+            Options.Add(DisableBuildServersOption);
+            Options.Add(VsTestTargetOption);
+        }
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index 5514e9793798..6915f7991add 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -1,19 +1,15 @@
 // 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.ObjectModel;
 using System.CommandLine;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Extensions;
-using Microsoft.TemplateEngine.Cli.Commands;
-using Microsoft.TemplateEngine.Cli.Help;
 using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
-internal abstract class TestCommandDefinition : Command
+internal abstract partial class TestCommandDefinition : Command
 {
     private const string Link = "https://aka.ms/dotnet-test";
 
@@ -92,355 +88,4 @@ private sealed class GlobalJsonTestNode
         [JsonPropertyName("runner")]
         public string RunnerName { get; set; } = null!;
     }
-
-    public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHelp
-    {
-        public readonly Option<string> ProjectOrSolutionOption = new("--project")
-        {
-            Description = CliCommandStrings.CmdProjectOrSolutionDescriptionFormat,
-            HelpName = CliCommandStrings.CmdProjectOrSolutionPathName,
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        public readonly Option<string> SolutionOption = new("--solution")
-        {
-            Description = CliCommandStrings.CmdSolutionDescription,
-            HelpName = CliCommandStrings.CmdSolutionPathName,
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        public readonly Option<string> TestModulesFilterOption = new("--test-modules")
-        {
-            Description = CliCommandStrings.CmdTestModulesDescription,
-            HelpName = CliCommandStrings.CmdExpressionName
-        };
-
-        public readonly Option<string> TestModulesRootDirectoryOption = new("--root-directory")
-        {
-            Description = CliCommandStrings.CmdTestModulesRootDirectoryDescription,
-            HelpName = CliCommandStrings.CmdRootPathName,
-        };
-
-        public const string ResultsDirectoryOptionName = "--results-directory";
-
-        public readonly Option<string> ResultsDirectoryOption = new(ResultsDirectoryOptionName)
-        {
-            Description = CliCommandStrings.CmdResultsDirectoryDescription,
-            HelpName = CliCommandStrings.CmdPathToResultsDirectory,
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        public const string ConfigFileOptionName = "--config-file";
-
-        public readonly Option<string> ConfigFileOption = new(ConfigFileOptionName)
-        {
-            Description = CliCommandStrings.CmdConfigFileDescription,
-            HelpName = CliCommandStrings.CmdConfigFilePath,
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        public const string DiagnosticOutputDirectoryOptionName = "--diagnostic-output-directory";
-
-        public readonly Option<string> DiagnosticOutputDirectoryOption = new(DiagnosticOutputDirectoryOptionName)
-        {
-            Description = CliCommandStrings.CmdDiagnosticOutputDirectoryDescription,
-            HelpName = CliCommandStrings.CmdDiagnosticOutputDirectoryPath,
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        public readonly Option<int> MaxParallelTestModulesOption = new("--max-parallel-test-modules")
-        {
-            Description = CliCommandStrings.CmdMaxParallelTestModulesDescription,
-            HelpName = CliCommandStrings.CmdNumberName
-        };
-
-        public readonly Option<int> MinimumExpectedTestsOption = new("--minimum-expected-tests")
-        {
-            Description = CliCommandStrings.CmdMinimumExpectedTestsDescription,
-            HelpName = CliCommandStrings.CmdNumberName
-        };
-
-        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-
-        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
-
-        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
-
-        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-
-        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
-
-        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-
-        public readonly Option<bool> NoBuildOption = new("--no-build")
-        {
-            Description = CliCommandStrings.CmdNoBuildDescription
-        };
-
-        public readonly Option<bool> NoAnsiOption = new("--no-ansi")
-        {
-            Description = CliCommandStrings.CmdNoAnsiDescription,
-            Arity = ArgumentArity.Zero
-        };
-
-        public readonly Option<bool> NoProgressOption = new("--no-progress")
-        {
-            Description = CliCommandStrings.CmdNoProgressDescription,
-            Arity = ArgumentArity.Zero
-        };
-
-        public readonly Option<OutputOptions> OutputOption = new("--output")
-        {
-            Description = CliCommandStrings.CmdTestOutputDescription,
-            Arity = ArgumentArity.ExactlyOne
-        };
-
-        public const string ListTestsOptionName = "--list-tests";
-
-        public readonly Option<string> ListTestsOption = new(ListTestsOptionName)
-        {
-            Description = CliCommandStrings.CmdListTestsDescription,
-            Arity = ArgumentArity.Zero
-        };
-
-        public readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
-        {
-            Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
-            Arity = ArgumentArity.Zero
-        };
-
-        public readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
-        {
-            Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
-        };
-
-        public readonly Option<string[]> MTPTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget);
-
-        public ICustomHelp? CustomHelpLayoutProvider { get; set; }
-
-        public MicrosoftTestingPlatform()
-            : base(CliCommandStrings.DotnetTestCommandMTPDescription)
-        {
-            Options.Add(ProjectOrSolutionOption);
-            Options.Add(SolutionOption);
-            Options.Add(TestModulesFilterOption);
-            Options.Add(TestModulesRootDirectoryOption);
-            Options.Add(ResultsDirectoryOption);
-            Options.Add(ConfigFileOption);
-            Options.Add(DiagnosticOutputDirectoryOption);
-            Options.Add(MaxParallelTestModulesOption);
-            Options.Add(MinimumExpectedTestsOption);
-            Options.Add(ArchitectureOption);
-            Options.Add(EnvOption);
-            Options.Add(PropertiesOption);
-            Options.Add(ConfigurationOption);
-            Options.Add(FrameworkOption);
-            Options.Add(OperatingSystemOption);
-            Options.Add(RuntimeOption);
-            Options.Add(VerbosityOption);
-            Options.Add(NoRestoreOption);
-            Options.Add(NoBuildOption);
-            Options.Add(NoAnsiOption);
-            Options.Add(NoProgressOption);
-            Options.Add(OutputOption);
-            Options.Add(ListTestsOption);
-            Options.Add(NoLaunchProfileOption);
-            Options.Add(NoLaunchProfileArgumentsOption);
-            Options.Add(MTPTargetOption);
-        }
-
-        public IEnumerable<Action<HelpContext>> CustomHelpLayout()
-            => CustomHelpLayoutProvider?.CustomHelpLayout() ?? [];
-    }
-
-    public sealed class VSTest : TestCommandDefinition
-    {
-        public readonly Option<string> SettingsOption = new Option<string>("--settings", "-s")
-        {
-            Description = CliCommandStrings.CmdSettingsDescription,
-            HelpName = CliCommandStrings.CmdSettingsFile
-        }.ForwardAsSingle(o => $"-property:VSTestSetting={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
-
-        public readonly Option<bool> ListTestsOption = new Option<bool>("--list-tests", "-t")
-        {
-            Description = CliCommandStrings.CmdListTestsDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:VSTestListTests=true");
-
-        public readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
-
-        public readonly Option<string> FilterOption = new Option<string>("--filter")
-        {
-            Description = CliCommandStrings.CmdTestCaseFilterDescription,
-            HelpName = CliCommandStrings.CmdTestCaseFilterExpression
-        }.ForwardAsSingle(o => $"-property:VSTestTestCaseFilter={VSTestOptions.SurroundWithDoubleQuotes(o!)}");
-
-        public readonly Option<IEnumerable<string>> AdapterOption = new Option<IEnumerable<string>>("--test-adapter-path")
-        {
-            Description = CliCommandStrings.CmdTestAdapterPathDescription,
-            HelpName = CliCommandStrings.CmdTestAdapterPath
-        }.ForwardAsSingle(o => $"-property:VSTestTestAdapterPath={VSTestOptions.SurroundWithDoubleQuotes(string.Join(";", o!.Select(CommandDirectoryContext.GetFullPath)))}")
-        .AllowSingleArgPerToken();
-
-        public readonly Option<IEnumerable<string>> LoggerOption = new Option<IEnumerable<string>>("--logger", "-l")
-        {
-            Description = CliCommandStrings.CmdLoggerDescription,
-            HelpName = CliCommandStrings.CmdLoggerOption
-        }.ForwardAsSingle(o =>
-        {
-            var loggersString = string.Join(";", VSTestOptions.GetSemiColonEscapedArgs(o!));
-            return $"-property:VSTestLogger={VSTestOptions.SurroundWithDoubleQuotes(loggersString)}";
-        })
-        .AllowSingleArgPerToken();
-
-        public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-        {
-            Description = CliCommandStrings.CmdOutputDescription,
-            HelpName = CliCommandStrings.TestCmdOutputDir
-        }
-        .ForwardAsOutputPath("OutputPath", true);
-
-        public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-
-        public readonly Option<string> DiagOption = new Option<string>("--diag", "-d")
-        {
-            Description = CliCommandStrings.CmdPathTologFileDescription,
-            HelpName = CliCommandStrings.CmdPathToLogFile
-        }
-        .ForwardAsSingle(o => $"-property:VSTestDiag={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
-
-        public readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
-        {
-            Description = CliCommandStrings.CmdNoBuildDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:VSTestNoBuild=true");
-
-        public readonly Option<string> ResultsOption = new Option<string>("--results-directory")
-        {
-            Description = CliCommandStrings.CmdResultsDirectoryDescription,
-            HelpName = CliCommandStrings.CmdPathToResultsDirectory
-        }.ForwardAsSingle(o => $"-property:VSTestResultsDirectory={VSTestOptions.SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
-
-        public readonly Option<IEnumerable<string>> CollectOption = new Option<IEnumerable<string>>("--collect")
-        {
-            Description = CliCommandStrings.cmdCollectDescription,
-            HelpName = CliCommandStrings.cmdCollectFriendlyName
-        }.ForwardAsSingle(o => $"-property:VSTestCollect=\"{string.Join(";", VSTestOptions.GetSemiColonEscapedArgs(o!))}\"")
-        .AllowSingleArgPerToken();
-
-        public readonly Option<bool> BlameOption = new Option<bool>("--blame")
-        {
-            Description = CliCommandStrings.CmdBlameDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardIfEnabled("-property:VSTestBlame=true");
-
-        public readonly Option<bool> BlameCrashOption = new Option<bool>("--blame-crash")
-        {
-            Description = CliCommandStrings.CmdBlameCrashDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardIfEnabled("-property:VSTestBlameCrash=true");
-
-        public readonly Option<string> BlameCrashDumpOption = CreateBlameCrashDumpOption();
-
-        public readonly Option<bool> BlameCrashAlwaysOption = new Option<bool>("--blame-crash-collect-always")
-        {
-            Description = CliCommandStrings.CmdBlameCrashCollectAlwaysDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardIfEnabled(["-property:VSTestBlameCrash=true", "-property:VSTestBlameCrashCollectAlways=true"]);
-
-        public readonly Option<bool> BlameHangOption = new Option<bool>("--blame-hang")
-        {
-            Description = CliCommandStrings.CmdBlameHangDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:VSTestBlameHang=true");
-
-        public readonly Option<string> BlameHangDumpOption = CreateBlameHangDumpOption();
-
-        public readonly Option<string> BlameHangTimeoutOption = new Option<string>("--blame-hang-timeout")
-        {
-            Description = CliCommandStrings.CmdBlameHangTimeoutDescription,
-            HelpName = CliCommandStrings.HangTimeoutArgumentName
-        }.ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangTimeout={o}"]);
-
-        public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
-
-        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
-
-        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-
-        public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-
-        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-
-        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-
-        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
-
-        public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-
-        public readonly Option<string[]> VsTestTargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("VSTest");
-
-        private static Option<string> CreateBlameCrashDumpOption()
-        {
-            Option<string> result = new Option<string>("--blame-crash-dump-type")
-            {
-                Description = CliCommandStrings.CmdBlameCrashDumpTypeDescription,
-                HelpName = CliCommandStrings.CrashDumpTypeArgumentName,
-            }
-            .ForwardAsMany(o => ["-property:VSTestBlameCrash=true", $"-property:VSTestBlameCrashDumpType={o}"]);
-            result.AcceptOnlyFromAmong(["full", "mini"]);
-            return result;
-        }
-
-        private static Option<string> CreateBlameHangDumpOption()
-        {
-            Option<string> result = new Option<string>("--blame-hang-dump-type")
-            {
-                Description = CliCommandStrings.CmdBlameHangDumpTypeDescription,
-                HelpName = CliCommandStrings.HangDumpTypeArgumentName
-            }
-            .ForwardAsMany(o => ["-property:VSTestBlameHang=true", $"-property:VSTestBlameHangDumpType={o}"]);
-            result.AcceptOnlyFromAmong(["full", "mini", "none"]);
-            return result;
-        }
-
-        public VSTest()
-            : base(CliCommandStrings.DotnetTestCommandVSTestDescription)
-        {
-            // We are on purpose not capturing the solution, project or directory here. We want to pass it to the
-            // MSBuild command so we are letting it flow.
-
-            Options.Add(SettingsOption);
-            Options.Add(ListTestsOption);
-            Options.Add(TestEnvOption);
-            Options.Add(FilterOption);
-            Options.Add(AdapterOption);
-            Options.Add(LoggerOption);
-            Options.Add(OutputOption);
-            Options.Add(ArtifactsPathOption);
-            Options.Add(DiagOption);
-            Options.Add(NoBuildOption);
-            Options.Add(ResultsOption);
-            Options.Add(CollectOption);
-            Options.Add(BlameOption);
-            Options.Add(BlameCrashOption);
-            Options.Add(BlameCrashDumpOption);
-            Options.Add(BlameCrashAlwaysOption);
-            Options.Add(BlameHangOption);
-            Options.Add(BlameHangDumpOption);
-            Options.Add(BlameHangTimeoutOption);
-            Options.Add(NoLogoOption);
-            Options.Add(ConfigurationOption);
-            Options.Add(FrameworkOption);
-            Options.Add(RuntimeOption);
-            Options.Add(NoRestoreOption);
-            Options.Add(InteractiveOption);
-            Options.Add(VerbosityOption);
-            Options.Add(ArchitectureOption);
-            Options.Add(OperatingSystemOption);
-            Options.Add(PropertiesOption);
-            Options.Add(DisableBuildServersOption);
-            Options.Add(VsTestTargetOption);
-        }
-    }
 }

From 92d5fc13957161b650052b29105e53272be4bddc Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 12:17:11 -0800
Subject: [PATCH 12/20] Options as instance fields

---
 .../ProjectToolsCommandResolver.cs            |   9 +-
 src/Cli/dotnet/Commands/Build/BuildCommand.cs |  23 +++-
 .../Commands/Build/BuildCommandDefinition.cs  | 122 +++++++++---------
 .../Commands/Build/BuildCommandParser.cs      |   5 +-
 src/Cli/dotnet/Commands/Clean/CleanCommand.cs |  21 ++-
 .../Commands/Clean/CleanCommandDefinition.cs  |  85 ++++++------
 .../Commands/Clean/CleanCommandParser.cs      |  10 +-
 .../CleanFileBasedAppArtifactsCommand.cs      |  12 +-
 ...nFileBasedAppArtifactsCommandDefinition.cs |  31 +++--
 src/Cli/dotnet/Commands/CommandFactory.cs     |   8 +-
 src/Cli/dotnet/Commands/Pack/PackCommand.cs   |  37 +++---
 .../Commands/Pack/PackCommandDefinition.cs    |  77 +++++------
 .../dotnet/Commands/Publish/PublishCommand.cs |  29 +++--
 .../Publish/PublishCommandDefinition.cs       | 119 +++++++++--------
 .../Commands/Publish/PublishCommandParser.cs  |   5 +-
 .../dotnet/Commands/Restore/RestoreCommand.cs |  15 ++-
 .../Restore/RestoreCommandDefinition.cs       | 120 +++++++++--------
 .../Commands/Restore/RestoreCommandParser.cs  |   5 +-
 .../Restore/RestoreParserTests.cs             |  15 ++-
 19 files changed, 404 insertions(+), 344 deletions(-)

diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
index 99886ae33f91..6c0b4ba50a4e 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
@@ -385,7 +385,14 @@ internal void GenerateDepsJsonFile(
         string? stdOut;
         string? stdErr;
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments([..args], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, BuildCommandDefinition.TargetOption, BuildCommandDefinition.VerbosityOption, BuildCommandDefinition.NoLogoOption);
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
+            [.. args],
+            CommonOptions.PropertiesOption,
+            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreateMSBuildTargetOption(),
+            CommonOptions.CreateVerbosityOption(),
+            CommonOptions.CreateNoLogoOption());
+
         var forwardingAppWithoutLogging = new MSBuildForwardingAppWithoutLogging(msbuildArgs, msBuildExePath);
         if (forwardingAppWithoutLogging.ExecuteMSBuildOutOfProc)
         {
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommand.cs b/src/Cli/dotnet/Commands/Build/BuildCommand.cs
index 8c67ed030f36..82bc09304815 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommand.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommand.cs
@@ -19,18 +19,20 @@ public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
 
     public static CommandBase FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
+        var definition = (BuildCommandDefinition)parseResult.CommandResult.Command;
+
         parseResult.ShowHelpOrErrorIfAppropriate();
 
         CommonOptions.ValidateSelfContainedOptions(
-            parseResult.HasOption(BuildCommandDefinition.SelfContainedOption),
-            parseResult.HasOption(BuildCommandDefinition.NoSelfContainedOption));
+            parseResult.HasOption(definition.SelfContainedOption),
+            parseResult.HasOption(definition.NoSelfContainedOption));
 
-        bool noRestore = parseResult.HasOption(BuildCommandDefinition.NoRestoreOption);
+        bool noRestore = parseResult.HasOption(definition.NoRestoreOption);
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
-            BuildCommandParser.GetCommand(),
-            BuildCommandDefinition.SlnOrProjectOrFileArgument,
-            configureVirtualCommand: (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
+            definition,
+            definition.SlnOrProjectOrFileArgument,
+            createVirtualCommand: (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(appFilePath),
                 msbuildArgs: msbuildArgs)
             {
@@ -42,7 +44,14 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 noRestore: noRestore,
                 msbuildPath: msbuildPath
             ),
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, BuildCommandDefinition.TargetOption, BuildCommandDefinition.VerbosityOption, BuildCommandDefinition.NoLogoOption],
+            optionsToUseWhenParsingMSBuildFlags:
+            [
+                CommonOptions.PropertiesOption,
+                CommonOptions.RestorePropertiesOption,
+                CommonOptions.CreateMSBuildTargetOption(),
+                CommonOptions.CreateVerbosityOption(),
+                CommonOptions.CreateNoLogoOption()
+            ],
             parseResult,
             msbuildPath
         );
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index 987fefbec459..e47c11141c50 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -8,102 +8,98 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Build;
 
-internal static class BuildCommandDefinition
+internal sealed class BuildCommandDefinition : Command
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-build";
+    private const string Link = "https://aka.ms/dotnet-build";
 
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    public readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
         Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
 
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.BuildOutputOptionDescription,
         HelpName = CliCommandStrings.OutputOptionName
     }.ForwardAsOutputPath("OutputPath");
 
-    public static readonly Option<bool> NoIncrementalOption = new Option<bool>("--no-incremental")
+    public readonly Option<bool> NoIncrementalOption = new Option<bool>("--no-incremental")
     {
         Description = CliCommandStrings.NoIncrementalOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("--target:Rebuild");
 
-    public static readonly Option<bool> NoDependenciesOption = new Option<bool>("--no-dependencies")
+    public readonly Option<bool> NoDependenciesOption = new Option<bool>("--no-dependencies")
     {
         Description = CliCommandStrings.NoDependenciesOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("--property:BuildProjectReferences=false");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
 
-    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.BuildConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.BuildConfigurationOptionDescription);
 
     /// <summary>
     /// Build actually means 'run the default Target' generally in MSBuild
     /// </summary>
-    public static readonly Option<string[]?> TargetOption = CommonOptions.CreateMSBuildTargetOption();
-
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
-
-    public static readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
-    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-    public static readonly Option<bool> DebugOption = CommonOptions.DebugOption;
-    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-    public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-    public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
-    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
-    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
-    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
-
-    public static Command Create()
+    public readonly Option<string[]?> TargetOption = CommonOptions.CreateMSBuildTargetOption();
+
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+
+    public readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public readonly Option<bool> DebugOption = CommonOptions.DebugOption;
+    public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+    public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+
+    public BuildCommandDefinition()
+        : base("build", CliCommandStrings.BuildAppFullName)
     {
-        Command command = new("build", CliCommandStrings.BuildAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        ImplicitRestoreOptions.AddTo(command.Options);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(VersionSuffixOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(DebugOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(ArtifactsPathOption);
-        command.Options.Add(NoIncrementalOption);
-        command.Options.Add(NoDependenciesOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(SelfContainedOption);
-        command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(ArchitectureOption);
-        command.Options.Add(OperatingSystemOption);
-        command.Options.Add(DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(GetPropertyOption);
-        command.Options.Add(GetItemOption);
-        command.Options.Add(GetTargetResultOption);
-        command.Options.Add(GetResultOutputFileOption);
-
-        return command;
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        ImplicitRestoreOptions.AddTo(Options);
+        Options.Add(FrameworkOption);
+        Options.Add(ConfigurationOption);
+        Options.Add(RuntimeOption);
+        Options.Add(VersionSuffixOption);
+        Options.Add(NoRestoreOption);
+        Options.Add(InteractiveOption);
+        Options.Add(VerbosityOption);
+        Options.Add(DebugOption);
+        Options.Add(OutputOption);
+        Options.Add(ArtifactsPathOption);
+        Options.Add(NoIncrementalOption);
+        Options.Add(NoDependenciesOption);
+        Options.Add(NoLogoOption);
+        Options.Add(SelfContainedOption);
+        Options.Add(NoSelfContainedOption);
+        Options.Add(ArchitectureOption);
+        Options.Add(OperatingSystemOption);
+        Options.Add(DisableBuildServersOption);
+        Options.Add(TargetOption);
+        Options.Add(GetPropertyOption);
+        Options.Add(GetItemOption);
+        Options.Add(GetTargetResultOption);
+        Options.Add(GetResultOutputFileOption);
     }
 }
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
index 7759cdf1684c..3264feff6496 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
@@ -7,15 +7,16 @@ namespace Microsoft.DotNet.Cli.Commands.Build;
 
 internal static class BuildCommandParser
 {
-    private static readonly Command Command = SetAction(BuildCommandDefinition.Create());
+    private static readonly BuildCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command SetAction(Command command)
+    private static BuildCommandDefinition CreateCommand()
     {
+        var command = new BuildCommandDefinition();
         command.SetAction(BuildCommand.Run);
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
index e2074b7a7d58..60db55970d29 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
@@ -9,7 +9,7 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Clean;
 
-public class CleanCommand(MSBuildArgs msbuildArgs, string? msbuildPath = null) : MSBuildForwardingApp(msbuildArgs, msbuildPath)
+public sealed class CleanCommand(MSBuildArgs msbuildArgs, string? msbuildPath = null) : MSBuildForwardingApp(msbuildArgs, msbuildPath)
 {
     public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
     {
@@ -19,11 +19,13 @@ public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
 
     public static CommandBase FromParseResult(ParseResult result, string? msbuildPath = null)
     {
+        var definition = (CleanCommandDefinition)result.CommandResult.Command;
+
         result.ShowHelpOrErrorIfAppropriate();
         return CommandFactory.CreateVirtualOrPhysicalCommand(
-            CleanCommandParser.GetCommand(),
-            CleanCommandDefinition.SlnOrProjectOrFileArgument,
-            static (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
+            definition,
+            definition.SlnOrProjectOrFileArgument,
+            createVirtualCommand: static (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: appFilePath,
                 msbuildArgs: msbuildArgs)
             {
@@ -32,8 +34,15 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
                 NoCache = true,
                 NoWriteBuildMarkers = true,
             },
-            static (msbuildArgs, msbuildPath) => new CleanCommand(msbuildArgs, msbuildPath),
-            [ CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CleanCommandDefinition.TargetOption, CleanCommandDefinition.VerbosityOption, CleanCommandDefinition.NoLogoOption],
+            createPhysicalCommand: static (msbuildArgs, msbuildPath) => new CleanCommand(msbuildArgs, msbuildPath),
+            optionsToUseWhenParsingMSBuildFlags:
+            [
+                CommonOptions.PropertiesOption,
+                CommonOptions.RestorePropertiesOption,
+                CleanCommandDefinition.CreateTargetOption(),
+                CommonOptions.CreateVerbosityOption(VerbosityOptions.normal),
+                CommonOptions.CreateNoLogoOption()
+            ],
             result,
             msbuildPath
         );
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
index c5a6fef2eff3..58410ea9c14b 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
@@ -8,65 +8,68 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Clean;
 
-internal static class CleanCommandDefinition
+internal sealed class CleanCommandDefinition : Command
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-clean";
+    public new const string Name = "clean";
+    private const string Link = "https://aka.ms/dotnet-clean";
 
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    public readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
         Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.CleanCmdOutputDirDescription,
         HelpName = CliCommandStrings.CleanCmdOutputDir
     }.ForwardAsOutputPath("OutputPath");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Clean");
+    public readonly Option<string[]> TargetOption = CreateTargetOption();
 
-    public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.normal);
+    public readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.normal);
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription);
-    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
-    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
-    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
-    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription);
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
 
-    public static Command Create()
+    public readonly Command FileBasedAppsCommand = new CleanFileBasedAppArtifactsCommandDefinition();
+
+    public CleanCommandDefinition()
+        : base(Name, CliCommandStrings.CleanAppFullName)
     {
-        Command command = new("clean", CliCommandStrings.CleanAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(ArtifactsPathOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(GetPropertyOption);
-        command.Options.Add(GetItemOption);
-        command.Options.Add(GetTargetResultOption);
-        command.Options.Add(GetResultOutputFileOption);
-        command.Subcommands.Add(CleanFileBasedAppArtifactsCommandDefinition.Create());
-
-        return command;
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        Options.Add(FrameworkOption);
+        Options.Add(RuntimeOption);
+        Options.Add(ConfigurationOption);
+        Options.Add(InteractiveOption);
+        Options.Add(VerbosityOption);
+        Options.Add(OutputOption);
+        Options.Add(ArtifactsPathOption);
+        Options.Add(NoLogoOption);
+        Options.Add(DisableBuildServersOption);
+        Options.Add(TargetOption);
+        Options.Add(GetPropertyOption);
+        Options.Add(GetItemOption);
+        Options.Add(GetTargetResultOption);
+        Options.Add(GetResultOutputFileOption);
+
+        Subcommands.Add(FileBasedAppsCommand);
     }
+
+    public static Option<string[]> CreateTargetOption()
+        => CommonOptions.CreateRequiredMSBuildTargetOption("Clean");
 }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
index 8a9237d558b0..6d93cb64a4db 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
@@ -8,20 +8,18 @@ namespace Microsoft.DotNet.Cli.Commands.Clean;
 
 internal static class CleanCommandParser
 {
-    private static readonly Command Command = SetAction(CleanCommandDefinition.Create());
+    private static readonly CleanCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command SetAction(Command command)
+    private static CleanCommandDefinition CreateCommand()
     {
+        var command = new CleanCommandDefinition();
         command.SetAction(CleanCommand.Run);
-
-        command.Subcommands.Single(c => c.Name == CleanFileBasedAppArtifactsCommandDefinition.Name)
-            .SetAction(parseResult => new CleanFileBasedAppArtifactsCommand(parseResult).Execute());
-
+        command.FileBasedAppsCommand.SetAction(parseResult => new CleanFileBasedAppArtifactsCommand(parseResult).Execute());
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs
index f449417b0340..ff8836713522 100644
--- a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs
+++ b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs
@@ -11,11 +11,11 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Clean.FileBasedAppArtifacts;
 
-internal sealed class CleanFileBasedAppArtifactsCommand(ParseResult parseResult) : CommandBase(parseResult)
+internal sealed class CleanFileBasedAppArtifactsCommand(ParseResult parseResult) : CommandBase<CleanFileBasedAppArtifactsCommandDefinition>(parseResult)
 {
     public override int Execute()
     {
-        bool dryRun = _parseResult.GetValue(CleanFileBasedAppArtifactsCommandDefinition.DryRunOption);
+        bool dryRun = _parseResult.GetValue(Definition.DryRunOption);
 
         using var metadataFileStream = OpenMetadataFile();
 
@@ -71,7 +71,7 @@ private IEnumerable<DirectoryInfo> GetFoldersToRemove()
 
         Reporter.Output.WriteLine(CliCommandStrings.CleanFileBasedAppArtifactsScanning, directory.FullName);
 
-        var days = _parseResult.GetValue(CleanFileBasedAppArtifactsCommandDefinition.DaysOption);
+        var days = _parseResult.GetValue(Definition.DaysOption);
         var cutoff = DateTime.UtcNow.AddDays(-days);
 
         foreach (var subdir in directory.GetDirectories())
@@ -90,7 +90,7 @@ private static FileInfo GetMetadataFile()
 
     private FileStream? OpenMetadataFile()
     {
-        if (!_parseResult.GetValue(CleanFileBasedAppArtifactsCommandDefinition.AutomaticOption))
+        if (!_parseResult.GetValue(Definition.AutomaticOption))
         {
             return null;
         }
@@ -127,9 +127,9 @@ public static void StartAutomaticCleanupIfNeeded()
                 FileName = new Muxer().MuxerPath,
                 Arguments = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(
                 [
-                    CleanCommandParser.GetCommand().Name,
+                    CleanCommandDefinition.Name,
                     CleanFileBasedAppArtifactsCommandDefinition.Name,
-                    CleanFileBasedAppArtifactsCommandDefinition.AutomaticOption.Name,
+                    CleanFileBasedAppArtifactsCommandDefinition.AutomaticOptionName,
                 ]),
                 UseShellExecute = false,
                 RedirectStandardInput = true,
diff --git a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs
index db9bf92bd846..9071e3cdcc63 100644
--- a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs
@@ -5,40 +5,39 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Clean.FileBasedAppArtifacts;
 
-internal sealed class CleanFileBasedAppArtifactsCommandDefinition
+internal sealed class CleanFileBasedAppArtifactsCommandDefinition : Command
 {
-    public const string Name = "file-based-apps";
+    public new const string Name = "file-based-apps";
 
-    public static readonly Option<bool> DryRunOption = new("--dry-run")
+    public readonly Option<bool> DryRunOption = new("--dry-run")
     {
         Description = CliCommandStrings.CleanFileBasedAppArtifactsDryRun,
         Arity = ArgumentArity.Zero,
     };
 
-    public static readonly Option<int> DaysOption = new("--days")
+    public readonly Option<int> DaysOption = new("--days")
     {
         Description = CliCommandStrings.CleanFileBasedAppArtifactsDays,
         DefaultValueFactory = _ => 30,
     };
 
+    public const string AutomaticOptionName = "--automatic";
+
     /// <summary>
     /// Specified internally when the command is started automatically in background by <c>dotnet run</c>.
     /// Causes <see cref="RunFileArtifactsMetadata.LastAutomaticCleanupUtc"/> to be updated.
     /// </summary>
-    public static readonly Option<bool> AutomaticOption = new("--automatic")
+    public readonly Option<bool> AutomaticOption = new(AutomaticOptionName)
     {
         Hidden = true,
     };
 
-    public static Command Create()
-        => new(Name, CliCommandStrings.CleanFileBasedAppArtifactsCommandDescription)
-        {
-            Hidden = true,
-            Options =
-            {
-                DryRunOption,
-                DaysOption,
-                AutomaticOption,
-            },
-        };
+    public CleanFileBasedAppArtifactsCommandDefinition()
+        : base(Name, CliCommandStrings.CleanFileBasedAppArtifactsCommandDescription)
+    {
+        Hidden = true;
+        Options.Add(DryRunOption);
+        Options.Add(DaysOption);
+        Options.Add(AutomaticOption);
+    }
 }
diff --git a/src/Cli/dotnet/Commands/CommandFactory.cs b/src/Cli/dotnet/Commands/CommandFactory.cs
index 05514de391f4..6f50a6b2d4d7 100644
--- a/src/Cli/dotnet/Commands/CommandFactory.cs
+++ b/src/Cli/dotnet/Commands/CommandFactory.cs
@@ -12,9 +12,9 @@ namespace Microsoft.DotNet.Cli.Commands;
 public static class CommandFactory
 {
     internal static CommandBase CreateVirtualOrPhysicalCommand(
-        System.CommandLine.Command command,
+        System.CommandLine.Command commandDefinition,
         Argument<string[]> catchAllUserInputArgument,
-        Func<MSBuildArgs, string, VirtualProjectBuildingCommand> configureVirtualCommand,
+        Func<MSBuildArgs, string, VirtualProjectBuildingCommand> createVirtualCommand,
         Func<MSBuildArgs, string?, CommandBase> createPhysicalCommand,
         IEnumerable<Option> optionsToUseWhenParsingMSBuildFlags,
         ParseResult parseResult,
@@ -23,7 +23,7 @@ internal static CommandBase CreateVirtualOrPhysicalCommand(
     {
         var args = parseResult.GetValue(catchAllUserInputArgument) ?? [];
         LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
-        var forwardedArgs = parseResult.OptionValuesToBeForwarded(command);
+        var forwardedArgs = parseResult.OptionValuesToBeForwarded(commandDefinition);
         if (nonBinLogArgs is [{ } arg] && VirtualProjectBuilder.IsValidEntryPointPath(arg))
         {
             var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments([.. forwardedArgs, .. binLogArgs],
@@ -35,7 +35,7 @@ internal static CommandBase CreateVirtualOrPhysicalCommand(
                 CommonOptions.CreateGetResultOutputFileOption(),
             ]);
             msbuildArgs = transformer?.Invoke(msbuildArgs) ?? msbuildArgs;
-            return configureVirtualCommand(msbuildArgs, Path.GetFullPath(arg));
+            return createVirtualCommand(msbuildArgs, Path.GetFullPath(arg));
         }
         else
         {
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommand.cs b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
index fe36ed860367..e4550abc2e67 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommand.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
@@ -31,17 +31,18 @@ public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
 
     public static CommandBase FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
-        var args = parseResult.GetValue(PackCommandDefinition.SlnOrProjectOrFileArgument) ?? [];
+        var definition = (PackCommandDefinition)parseResult.CommandResult.Command;
+        var args = parseResult.GetValue(definition.SlnOrProjectOrFileArgument) ?? [];
 
         LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
 
-        bool noBuild = parseResult.HasOption(PackCommandDefinition.NoBuildOption);
+        bool noBuild = parseResult.HasOption(definition.NoBuildOption);
 
-        bool noRestore = noBuild || parseResult.HasOption(PackCommandDefinition.NoRestoreOption);
+        bool noRestore = noBuild || parseResult.HasOption(definition.NoRestoreOption);
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
-            PackCommandParser.GetCommand(),
-            PackCommandDefinition.SlnOrProjectOrFileArgument,
+            definition,
+            definition.SlnOrProjectOrFileArgument,
             (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(appFilePath),
                 msbuildArgs: msbuildArgs)
@@ -58,18 +59,18 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
             [
                 CommonOptions.PropertiesOption,
                 CommonOptions.RestorePropertiesOption,
-                PackCommandDefinition.TargetOption,
-                PackCommandDefinition.VerbosityOption,
-                PackCommandDefinition.NoLogoOption
+                PackCommandDefinition.CreateTargetOption(),
+                CommonOptions.CreateVerbosityOption(),
+                CommonOptions.CreateNoLogoOption()
             ],
             parseResult,
             msbuildPath,
-            (msbuildArgs) =>
+            transformer: (msbuildArgs) =>
             {
                 ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
                     new ReleasePropertyProjectLocator.DependentCommandOptions(
                             nonBinLogArgs,
-                            parseResult.HasOption(PackCommandDefinition.ConfigurationOption) ? parseResult.GetValue(PackCommandDefinition.ConfigurationOption) : null
+                            parseResult.HasOption(definition.ConfigurationOption) ? parseResult.GetValue(definition.ConfigurationOption) : null
                         )
                 );
                 return msbuildArgs.CloneWithAdditionalProperties(projectLocator.GetCustomDefaultConfigurationValueIfSpecified());
@@ -90,7 +91,9 @@ private static LogLevel MappingVerbosityToNugetLogLevel(VerbosityOptions? verbos
 
     public static int RunPackCommand(ParseResult parseResult)
     {
-        var args = parseResult.GetValue(PackCommandDefinition.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
+        var definition = (PackCommandDefinition)parseResult.CommandResult.Command;
+
+        var args = parseResult.GetValue(definition.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
 
         if (args.Count != 1)
         {
@@ -104,8 +107,8 @@ public static int RunPackCommand(ParseResult parseResult)
         { 
             Logger = new NuGetConsoleLogger(),
             Exclude = new List<string>(),
-            OutputDirectory = parseResult.GetValue(PackCommandDefinition.OutputOption),
-            LogLevel = MappingVerbosityToNugetLogLevel(parseResult.GetValue(BuildCommandDefinition.VerbosityOption)),
+            OutputDirectory = parseResult.GetValue(definition.OutputOption),
+            LogLevel = MappingVerbosityToNugetLogLevel(parseResult.GetValue(definition.VerbosityOption)),
             Arguments = [nuspecPath]
         };
 
@@ -117,11 +120,11 @@ public static int RunPackCommand(ParseResult parseResult)
         if (globalProperties != null)
             packArgs.Properties.AddRange(globalProperties);
 
-        var version = parseResult.GetValue(PackCommandDefinition.VersionOption);
+        var version = parseResult.GetValue(definition.VersionOption);
         if (version != null)
             packArgs.Version = version.ToNormalizedString();
 
-        var configuration = parseResult.GetValue(PackCommandDefinition.ConfigurationOption) ?? "Debug";
+        var configuration = parseResult.GetValue(definition.ConfigurationOption) ?? "Debug";
         packArgs.Properties["configuration"] = configuration;
 
         var packCommandRunner = new PackCommandRunner(packArgs, null);
@@ -132,10 +135,12 @@ public static int RunPackCommand(ParseResult parseResult)
 
     public static int Run(ParseResult parseResult)
     {
+        var definition = (PackCommandDefinition)parseResult.CommandResult.Command;
+
         parseResult.HandleDebugSwitch();
         parseResult.ShowHelpOrErrorIfAppropriate();
 
-        var args = parseResult.GetValue(PackCommandDefinition.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
+        var args = parseResult.GetValue(definition.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
 
         if (args.Count > 0 && Path.GetExtension(args[0]).Equals(".nuspec", StringComparison.OrdinalIgnoreCase))
         {
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 3f39a1daf5ca..8b17d5525f0a 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -13,82 +13,82 @@ internal sealed class PackCommandDefinition : Command
 {
     private const string Link = "https://aka.ms/dotnet-pack";
 
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    public readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
         Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
 
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.PackCmdOutputDirDescription,
         HelpName = CliCommandStrings.PackCmdOutputDir
     }.ForwardAsSingle(o => $"-property:PackageOutputPath={CommandDirectoryContext.GetFullPath(o)}");
 
-    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
+    public readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
     {
         Description = CliCommandStrings.CmdNoBuildOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:NoBuild=true");
 
-    public static readonly Option<bool> IncludeSymbolsOption = new Option<bool>("--include-symbols")
+    public readonly Option<bool> IncludeSymbolsOption = new Option<bool>("--include-symbols")
     {
         Description = CliCommandStrings.CmdIncludeSymbolsDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:IncludeSymbols=true");
 
-    public static readonly Option<bool> IncludeSourceOption = new Option<bool>("--include-source")
+    public readonly Option<bool> IncludeSourceOption = new Option<bool>("--include-source")
     {
         Description = CliCommandStrings.CmdIncludeSourceDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:IncludeSource=true");
 
-    public static readonly Option<bool> ServiceableOption = new Option<bool>("--serviceable", "-s")
+    public readonly Option<bool> ServiceableOption = new Option<bool>("--serviceable", "-s")
     {
         Description = CliCommandStrings.CmdServiceableDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:Serviceable=true");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
+    public readonly Option<string[]> TargetOption = CreateTargetOption();
 
-    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-    public static readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
-    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
-    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
-    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
-    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
-    public static readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
-    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public static Option<NuGetVersion> VersionOption =
-        new Option<NuGetVersion>("--version")
+    public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
+    public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+    public readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
+    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+
+    public readonly Option<NuGetVersion> VersionOption = new Option<NuGetVersion>("--version")
+    {
+        Description = CliCommandStrings.PackCmdVersionDescription,
+        HelpName = CliCommandStrings.PackCmdVersion,
+        Arity = ArgumentArity.ExactlyOne,
+        CustomParser = r =>
         {
-            Description = CliCommandStrings.PackCmdVersionDescription,
-            HelpName = CliCommandStrings.PackCmdVersion,
-            Arity = ArgumentArity.ExactlyOne,
-            CustomParser = r =>
-            {
-                if (r.Tokens.Count == 0)
-                    return null;
-                var value = r.Tokens[0].Value;
-                if (NuGetVersion.TryParse(value, out var version))
-                    return version;
-                r.AddError(string.Format(CliStrings.InvalidVersion, value));
+            if (r.Tokens.Count == 0)
                 return null;
+            var value = r.Tokens[0].Value;
+            if (NuGetVersion.TryParse(value, out var version))
+                return version;
+            r.AddError(string.Format(CliStrings.InvalidVersion, value));
+            return null;
 
-            }
-        }.ForwardAsSingle(o => $"--property:PackageVersion={o}");
+        }
+    }.ForwardAsSingle(o => $"--property:PackageVersion={o}");
 
     public PackCommandDefinition()
         : base("pack", CliCommandStrings.PackAppFullName)
@@ -121,4 +121,7 @@ public PackCommandDefinition()
         Options.Add(NoDependenciesOption);
         Options.Add(RuntimeOption);
     }
+
+    public static Option<string[]> CreateTargetOption()
+        => CommonOptions.CreateRequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
 }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
index 19568315c08c..467b526b0a96 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
@@ -28,23 +28,25 @@ public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
 
     public static CommandBase FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
+        var definition = (PublishCommandDefinition)parseResult.CommandResult.Command;
+
         parseResult.HandleDebugSwitch();
         parseResult.ShowHelpOrErrorIfAppropriate();
 
-        string[] args = parseResult.GetValue(PublishCommandDefinition.SlnOrProjectOrFileArgument) ?? [];
+        string[] args = parseResult.GetValue(definition.SlnOrProjectOrFileArgument) ?? [];
 
         LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
 
-        CommonOptions.ValidateSelfContainedOptions(parseResult.HasOption(PublishCommandDefinition.SelfContainedOption),
-            parseResult.HasOption(PublishCommandDefinition.NoSelfContainedOption));
+        CommonOptions.ValidateSelfContainedOptions(parseResult.HasOption(definition.SelfContainedOption),
+            parseResult.HasOption(definition.NoSelfContainedOption));
 
-        bool noBuild = parseResult.HasOption(PublishCommandDefinition.NoBuildOption);
+        bool noBuild = parseResult.HasOption(definition.NoBuildOption);
 
-        bool noRestore = noBuild || parseResult.HasOption(PublishCommandDefinition.NoRestoreOption);
+        bool noRestore = noBuild || parseResult.HasOption(definition.NoRestoreOption);
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
-            PublishCommandParser.GetCommand(),
-            PublishCommandDefinition.SlnOrProjectOrFileArgument,
+            definition,
+            definition.SlnOrProjectOrFileArgument,
             (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(appFilePath),
                 msbuildArgs: msbuildArgs)
@@ -58,15 +60,22 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 noRestore: noRestore,
                 msbuildPath: msbuildPath
             ),
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, PublishCommandDefinition.TargetOption, PublishCommandDefinition.VerbosityOption, PublishCommandDefinition.NoLogoOption],
+            optionsToUseWhenParsingMSBuildFlags:
+            [
+                CommonOptions.PropertiesOption,
+                CommonOptions.RestorePropertiesOption,
+                PublishCommandDefinition.CreateTargetOption(),
+                CommonOptions.CreateVerbosityOption(),
+                CommonOptions.CreateNoLogoOption()
+            ],
             parseResult,
             msbuildPath,
             (msbuildArgs) =>
             {
                 var options = new ReleasePropertyProjectLocator.DependentCommandOptions(
                         nonBinLogArgs,
-                        parseResult.HasOption(PublishCommandDefinition.ConfigurationOption) ? parseResult.GetValue(PublishCommandDefinition.ConfigurationOption) : null,
-                        parseResult.HasOption(PublishCommandDefinition.FrameworkOption) ? parseResult.GetValue(PublishCommandDefinition.FrameworkOption) : null
+                        parseResult.HasOption(definition.ConfigurationOption) ? parseResult.GetValue(definition.ConfigurationOption) : null,
+                        parseResult.HasOption(definition.FrameworkOption) ? parseResult.GetValue(definition.FrameworkOption) : null
                     );
                 var projectLocator = new ReleasePropertyProjectLocator(parseResult, MSBuildPropertyNames.PUBLISH_RELEASE, options);
                 var releaseModeProperties = projectLocator.GetCustomDefaultConfigurationValueIfSpecified();
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index 5b429519d66f..b186d0ef655c 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -9,99 +9,98 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Publish;
 
-internal static class PublishCommandDefinition
+internal sealed class PublishCommandDefinition : Command
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-publish";
+    private const string Link = "https://aka.ms/dotnet-publish";
 
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    public readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
         Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
 
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    public readonly Option<string> OutputOption = new Option<string>("--output", "-o")
     {
         Description = CliCommandStrings.PublishOutputOptionDescription,
         HelpName = CliCommandStrings.PublishOutputOption
     }.ForwardAsOutputPath("PublishDir");
 
-    public static readonly Option<IEnumerable<string>> ManifestOption = new Option<IEnumerable<string>>("--manifest")
+    public readonly Option<IEnumerable<string>> ManifestOption = new Option<IEnumerable<string>>("--manifest")
     {
         Description = CliCommandStrings.ManifestOptionDescription,
         HelpName = CliCommandStrings.ManifestOption
     }.ForwardAsSingle(o => $"-property:TargetManifestFiles={string.Join("%3B", o.Select(CommandDirectoryContext.GetFullPath))}")
     .AllowSingleArgPerToken();
 
-    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
+    public readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
     {
         Description = CliCommandStrings.NoBuildOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:NoBuild=true");
 
-    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
 
-    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
+    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
-    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
+    public readonly Option<string[]> TargetOption = CreateTargetOption();
 
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public static readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
-    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-    public static readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
-    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-    public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-    public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
-    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
-    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
-    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+    public readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
+    public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+    public readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+    public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
 
-    public static Command Create()
+    public PublishCommandDefinition()
+        : base("publish", CliCommandStrings.PublishAppDescription)
     {
-        var command = new Command("publish", CliCommandStrings.PublishAppDescription)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        ImplicitRestoreOptions.AddTo(command.Options);
-        command.Options.Add(NoDependenciesOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(ArtifactsPathOption);
-        command.Options.Add(ManifestOption);
-        command.Options.Add(NoBuildOption);
-        command.Options.Add(SelfContainedOption);
-        command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(VersionSuffixOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(ArchitectureOption);
-        command.Options.Add(OperatingSystemOption);
-        command.Options.Add(DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(GetPropertyOption);
-        command.Options.Add(GetItemOption);
-        command.Options.Add(GetTargetResultOption);
-        command.Options.Add(GetResultOutputFileOption);
-
-        return command;
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        ImplicitRestoreOptions.AddTo(Options);
+        Options.Add(NoDependenciesOption);
+        Options.Add(OutputOption);
+        Options.Add(ArtifactsPathOption);
+        Options.Add(ManifestOption);
+        Options.Add(NoBuildOption);
+        Options.Add(SelfContainedOption);
+        Options.Add(NoSelfContainedOption);
+        Options.Add(NoLogoOption);
+        Options.Add(FrameworkOption);
+        Options.Add(RuntimeOption);
+        Options.Add(ConfigurationOption);
+        Options.Add(VersionSuffixOption);
+        Options.Add(InteractiveOption);
+        Options.Add(NoRestoreOption);
+        Options.Add(VerbosityOption);
+        Options.Add(ArchitectureOption);
+        Options.Add(OperatingSystemOption);
+        Options.Add(DisableBuildServersOption);
+        Options.Add(TargetOption);
+        Options.Add(GetPropertyOption);
+        Options.Add(GetItemOption);
+        Options.Add(GetTargetResultOption);
+        Options.Add(GetResultOutputFileOption);
     }
+
+    public static Option<string[]> CreateTargetOption()
+        => CommonOptions.CreateRequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
 }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
index 623c4cadfeab..fbe4e55e2955 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
@@ -7,15 +7,16 @@ namespace Microsoft.DotNet.Cli.Commands.Publish;
 
 internal static class PublishCommandParser
 {
-    private static readonly Command Command = SetAction(PublishCommandDefinition.Create());
+    private static readonly PublishCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command SetAction(Command command)
+    private static PublishCommandDefinition CreateCommand()
     {
+        var command = new PublishCommandDefinition();
         command.SetAction(PublishCommand.Run);
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
index f0e3fdff688b..902b40ec60f3 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
@@ -19,12 +19,14 @@ public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
 
     public static CommandBase FromParseResult(ParseResult result, string? msbuildPath = null)
     {
+        var definition = (RestoreCommandDefinition)result.CommandResult.Command;
+
         result.HandleDebugSwitch();
         result.ShowHelpOrErrorIfAppropriate();
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
-            RestoreCommandParser.GetCommand(),
-            RestoreCommandDefinition.SlnOrProjectOrFileArgument,
+            definition,
+            definition.SlnOrProjectOrFileArgument,
             static (msbuildArgs, appFilePath) =>
             {
                 return new VirtualProjectBuildingCommand(
@@ -40,7 +42,14 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
             {
                 return CreateForwarding(msbuildArgs, msbuildPath);
             },
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, RestoreCommandDefinition.TargetOption, RestoreCommandDefinition.VerbosityOption, RestoreCommandDefinition.NoLogoOption],
+            optionsToUseWhenParsingMSBuildFlags:
+            [
+                CommonOptions.PropertiesOption,
+                CommonOptions.RestorePropertiesOption,
+                RestoreCommandDefinition.CreateTargetOption(),
+                CommonOptions.CreateVerbosityOption(),
+                CommonOptions.CreateNoLogoOption()
+            ],
             result,
             msbuildPath
         );
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index df6fe15a3d8a..a0b6a2f48636 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -7,90 +7,95 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Restore;
 
-internal static class RestoreCommandDefinition
+internal sealed class RestoreCommandDefinition : Command
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-restore";
+    private const string Link = "https://aka.ms/dotnet-restore";
 
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    public readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
         Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    public static readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: true, useShortOptions: true);
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: true, useShortOptions: true);
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
-    public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
-    public static readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+    public readonly Option<string[]> TargetOption = CreateTargetOption();
+    public readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.minimal);
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-    public static readonly Option<IEnumerable<string>> RuntimeOption = CreateRuntimeOption(showHelp: true, useShortOptions: true);
-    public static readonly Option<bool> NoDependenciesOption = CreateNoDependenciesOption(showHelp: true);
-    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-    public static readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-    public static readonly Option<bool> UseLockFileOption = new Option<bool>("--use-lock-file")
+    public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+    public readonly Option<IEnumerable<string>> RuntimeOption = CreateRuntimeOption(showHelp: true, useShortOptions: true);
+    public readonly Option<bool> NoDependenciesOption = CreateNoDependenciesOption(showHelp: true);
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
+
+    public readonly Option<bool> UseLockFileOption = new Option<bool>("--use-lock-file")
     {
         Description = CliCommandStrings.CmdUseLockFileOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:RestorePackagesWithLockFile=true");
-    public static readonly Option<bool> LockedModeOption = new Option<bool>("--locked-mode")
+
+    public readonly Option<bool> LockedModeOption = new Option<bool>("--locked-mode")
     {
         Description = CliCommandStrings.CmdLockedModeOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:RestoreLockedMode=true");
-    public static readonly Option<string> LockFilePathOption = new Option<string>("--lock-file-path")
+
+    public readonly Option<string> LockFilePathOption = new Option<string>("--lock-file-path")
     {
         Description = CliCommandStrings.CmdLockFilePathOptionDescription,
         HelpName = CliCommandStrings.CmdLockFilePathOption
     }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}");
-    public static readonly Option<bool> ForceEvaluateOption = new Option<bool>("--force-evaluate")
+
+    public readonly Option<bool> ForceEvaluateOption = new Option<bool>("--force-evaluate")
     {
         Description = CliCommandStrings.CmdReevaluateOptionDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:RestoreForceEvaluate=true");
-    public static readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-    public static readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-    public static readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
-    public static readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
-    public static readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
-    public static readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
-
-    public static Command Create()
+
+    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+    public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
+    public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
+    public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
+    public readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
+
+    public RestoreCommandDefinition()
+        : base("restore", CliCommandStrings.RestoreAppFullName)
     {
-        var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(DisableBuildServersOption);
-
-        ImplicitRestoreOptions.AddTo(command.Options);
-
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(NoDependenciesOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(ArtifactsPathOption);
-        command.Options.Add(UseLockFileOption);
-        command.Options.Add(LockedModeOption);
-        command.Options.Add(LockFilePathOption);
-        command.Options.Add(ForceEvaluateOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(NoLogoOption);
-
-        command.Options.Add(ArchitectureOption);
-        command.Options.Add(OperatingSystemOption);
-        command.Options.Add(GetPropertyOption);
-        command.Options.Add(GetItemOption);
-        command.Options.Add(GetTargetResultOption);
-        command.Options.Add(GetResultOutputFileOption);
-
-        return command;
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        Options.Add(DisableBuildServersOption);
+
+        ImplicitRestoreOptions.AddTo(Options);
+
+        Options.Add(RuntimeOption);
+        Options.Add(NoDependenciesOption);
+        Options.Add(VerbosityOption);
+        Options.Add(InteractiveOption);
+        Options.Add(ArtifactsPathOption);
+        Options.Add(UseLockFileOption);
+        Options.Add(LockedModeOption);
+        Options.Add(LockFilePathOption);
+        Options.Add(ForceEvaluateOption);
+        Options.Add(TargetOption);
+        Options.Add(NoLogoOption);
+
+        Options.Add(ArchitectureOption);
+        Options.Add(OperatingSystemOption);
+        Options.Add(GetPropertyOption);
+        Options.Add(GetItemOption);
+        Options.Add(GetTargetResultOption);
+        Options.Add(GetResultOutputFileOption);
     }
 
-    private static string GetOsFromRid(string rid) => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
-    private static string GetArchFromRid(string rid) => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
+    private static string GetOsFromRid(string rid)
+        => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
+
+    private static string GetArchFromRid(string rid)
+        => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
+
     public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
     {
         List<string> convertedRids = [];
@@ -135,4 +140,7 @@ public static Option<bool> CreateNoDependenciesOption(bool showHelp)
             Arity = ArgumentArity.Zero,
             Hidden = !showHelp
         }.ForwardAs("-property:RestoreRecursive=false");
+
+    public static Option<string[]> CreateTargetOption()
+        => CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
 }
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
index 023214f2afa1..508a433cbe86 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
@@ -7,15 +7,16 @@ namespace Microsoft.DotNet.Cli.Commands.Restore;
 
 internal static class RestoreCommandParser
 {
-    private static readonly Command Command = SetAction(RestoreCommandDefinition.Create());
+    private static readonly RestoreCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command SetAction(Command command)
+    private static RestoreCommandDefinition CreateCommand()
     {
+        var command = new RestoreCommandDefinition();
         command.SetAction(RestoreCommand.Run);
         return command;
     }
diff --git a/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
index 0398f677165f..b65fdcddb974 100644
--- a/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
@@ -20,17 +20,18 @@ public RestoreCommandLineParserTests(ITestOutputHelper output)
         public void RestoreCapturesArgumentsToForwardToMSBuildWhenTargetIsSpecified()
         {
             var result = Parser.Parse(["dotnet", "restore", @".\some.csproj", "--packages", @"c:\.nuget\packages", "/p:SkipInvalidConfigurations=true"]);
-
-            result.GetValue(RestoreCommandDefinition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@".\some.csproj");
-            result.OptionValuesToBeForwarded(RestoreCommandParser.GetCommand()).Should().Contain(@"--property:SkipInvalidConfigurations=true");
+            var definition = Assert.IsType<RestoreCommandDefinition>(result.CommandResult.Command);
+            result.GetValue(definition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@".\some.csproj");
+            result.OptionValuesToBeForwarded(definition).Should().Contain(@"--property:SkipInvalidConfigurations=true");
         }
 
         [Fact]
         public void RestoreCapturesArgumentsToForwardToMSBuildWhenTargetIsNotSpecified()
         {
             var result = Parser.Parse(["dotnet", "restore", "--packages", @"c:\.nuget\packages", "/p:SkipInvalidConfigurations=true"]);
+            var definition = Assert.IsType<RestoreCommandDefinition>(result.CommandResult.Command);
 
-            result.OptionValuesToBeForwarded(RestoreCommandParser.GetCommand()).Should().Contain(@"--property:SkipInvalidConfigurations=true");
+            result.OptionValuesToBeForwarded(definition).Should().Contain(@"--property:SkipInvalidConfigurations=true");
         }
 
         [Fact]
@@ -39,9 +40,11 @@ public void RestoreDistinguishesRepeatSourceArgsFromCommandArgs()
             var restore =
                 Parser.Parse(["dotnet", "restore", "--no-cache", "--packages", @"D:\OSS\corefx\packages", "--source", "https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json", "--source", "https://dotnet.myget.org/F/dotnet-core/api/v3/index.json", "--source", "https://api.nuget.org/v3/index.json", @"D:\OSS\corefx\external\runtime\runtime.depproj"]);
 
-            restore.GetValue(RestoreCommandDefinition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@"D:\OSS\corefx\external\runtime\runtime.depproj");
+            var definition = Assert.IsType<RestoreCommandDefinition>(restore.CommandResult.Command);
+
+            restore.GetValue(definition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@"D:\OSS\corefx\external\runtime\runtime.depproj");
 
-            restore.GetValue(RestoreCommandDefinition.ImplicitRestoreOptions.SourceOption)
+            restore.GetValue(definition.ImplicitRestoreOptions.SourceOption)
                 .Should()
                 .BeEquivalentTo(
                     "https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json",

From 3bf3eb527033bac86841e3f004bb42aae8dc56a2 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 12:31:19 -0800
Subject: [PATCH 13/20] Eliminate unused LongFormatArchitectureOption

---
 src/Cli/dotnet/CommonOptions.cs                    | 14 +-------------
 src/Cli/dotnet/Extensions/ParseResultExtensions.cs |  4 +---
 2 files changed, 2 insertions(+), 16 deletions(-)

diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 76bdf1d2235f..5c045ba09d44 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -302,18 +302,6 @@ public static Option<bool> CreateDisableBuildServersOption() =>
             HelpName = CliStrings.ArchArgumentName
         }.SetForwardingFunction(ResolveArchOptionToRuntimeIdentifier);
 
-    public static Option<string> LongFormArchitectureOption =
-        new Option<string>("--arch")
-        {
-            Description = CliStrings.ArchitectureOptionDescription,
-            HelpName = CliStrings.ArchArgumentName
-        }.SetForwardingFunction(ResolveArchOptionToRuntimeIdentifier);
-
-    internal static string? ArchOptionValue(ParseResult parseResult) =>
-        string.IsNullOrEmpty(parseResult.GetValue(ArchitectureOption)) ?
-            parseResult.GetValue(LongFormArchitectureOption) :
-            parseResult.GetValue(ArchitectureOption);
-
     public static Option<string> OperatingSystemOption =
         new Option<string>("--os")
         {
@@ -456,7 +444,7 @@ internal static IEnumerable<string> ResolveOsOptionToRuntimeIdentifier(string? a
             throw new GracefulException(CliStrings.CannotSpecifyBothRuntimeAndOsOptions);
         }
 
-        var arch = parseResult.BothArchAndOsOptionsSpecified() ? ArchOptionValue(parseResult) : null;
+        var arch = parseResult.BothArchAndOsOptionsSpecified() ? parseResult.GetValue(ArchitectureOption) : null;
         return ResolveRidShorthandOptions(arg, arch);
     }
 
diff --git a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
index eb87125030f0..5e74f71bd7a5 100644
--- a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
@@ -171,9 +171,7 @@ public static bool DiagOptionPrecedesSubcommand(this string[] args, string subCo
     };
 
     public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =>
-        (parseResult.HasOption(CommonOptions.ArchitectureOption) ||
-        parseResult.HasOption(CommonOptions.LongFormArchitectureOption)) &&
-        parseResult.HasOption(CommonOptions.OperatingSystemOption);
+        parseResult.HasOption(CommonOptions.ArchitectureOption) && parseResult.HasOption(CommonOptions.OperatingSystemOption);
 
     public static bool UsingRunCommandShorthandProjectOption(this ParseResult parseResult)
     {

From e354b53a10693b6a464b6ced724af03af5697c25 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 13:15:21 -0800
Subject: [PATCH 14/20] Run command options

---
 src/Cli/dotnet/Commands/Run/RunCommand.cs     |  58 +++++++---
 .../Commands/Run/RunCommandDefinition.cs      | 108 ++++++++++--------
 .../dotnet/Commands/Run/RunCommandParser.cs   |   5 +-
 .../Extensions/ParseResultExtensions.cs       |  17 ---
 .../MSBuild/GivenDotnetRunInvocation.cs       |  15 ++-
 .../CommandTests/Run/RunFileTests.cs          |  26 ++---
 6 files changed, 130 insertions(+), 99 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index aa45281e29d8..588f9a5eeb4b 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -128,7 +128,7 @@ public int Execute()
     {
         if (NoBuild && NoCache)
         {
-            throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.NoCacheOption.Name, RunCommandDefinition.NoBuildOption.Name);
+            throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.NoCacheOptionName, RunCommandDefinition.NoBuildOptionName);
         }
 
         // Pre-run evaluation: Handle target framework selection for multi-targeted projects
@@ -688,7 +688,9 @@ public static RunCommand FromArgs(string[] args)
 
     public static RunCommand FromParseResult(ParseResult parseResult)
     {
-        if (parseResult.UsingRunCommandShorthandProjectOption())
+        var definition = (RunCommandDefinition)parseResult.CommandResult.Command;
+
+        if (UsingRunCommandShorthandProjectOption(parseResult))
         {
             Reporter.Output.WriteLine(CliCommandStrings.RunCommandProjectAbbreviationDeprecated.Yellow());
             parseResult = ModifyParseResultForShorthandProjectOption(parseResult);
@@ -698,11 +700,11 @@ public static RunCommand FromParseResult(ParseResult parseResult)
         // them to the restore args.
         // this is because we can't model the binlog command structure in MSbuild in the System.CommandLine parser, but we need
         // bl information to synchronize the restore and build logger configurations
-        var applicationArguments = parseResult.GetValue(RunCommandDefinition.ApplicationArguments)?.ToList();
+        var applicationArguments = parseResult.GetValue(definition.ApplicationArguments)?.ToList();
 
         LoggerUtility.SeparateBinLogArguments(applicationArguments, out var binLogArgs, out var nonBinLogArgs);
 
-        var msbuildProperties = parseResult.OptionValuesToBeForwarded(RunCommandParser.GetCommand()).ToList();
+        var msbuildProperties = parseResult.OptionValuesToBeForwarded(definition).ToList();
         if (binLogArgs.Count > 0)
         {
             msbuildProperties.AddRange(binLogArgs);
@@ -714,12 +716,12 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             parseResult.Tokens.TakeWhile(static t => t.Type != TokenType.DoubleDash)
                 .Any(static t => t is { Type: TokenType.Argument, Value: "-" });
 
-        string? projectOption = parseResult.GetValue(RunCommandDefinition.ProjectOption);
-        string? fileOption = parseResult.GetValue(RunCommandDefinition.FileOption);
+        string? projectOption = parseResult.GetValue(definition.ProjectOption);
+        string? fileOption = parseResult.GetValue(definition.FileOption);
 
         if (projectOption != null && fileOption != null)
         {
-            throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.ProjectOption.Name, RunCommandDefinition.FileOption.Name);
+            throw new GracefulException(CliCommandStrings.CannotCombineOptions, definition.ProjectOption.Name, definition.FileOption.Name);
         }
 
         string[] args = [.. nonBinLogArgs];
@@ -730,8 +732,8 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             ref args,
             out string? entryPointFilePath);
 
-        bool noBuild = parseResult.HasOption(RunCommandDefinition.NoBuildOption);
-        string launchProfile = parseResult.GetValue(RunCommandDefinition.LaunchProfileOption) ?? string.Empty;
+        bool noBuild = parseResult.HasOption(definition.NoBuildOption);
+        string launchProfile = parseResult.GetValue(definition.LaunchProfileOption) ?? string.Empty;
 
         if (readCodeFromStdin && entryPointFilePath != null)
         {
@@ -739,12 +741,12 @@ public static RunCommand FromParseResult(ParseResult parseResult)
 
             if (noBuild)
             {
-                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.NoBuildOption.Name);
+                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, definition.NoBuildOption.Name);
             }
 
             if (!string.IsNullOrWhiteSpace(launchProfile))
             {
-                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.LaunchProfileOption.Name);
+                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, definition.LaunchProfileOption.Name);
             }
 
             // If '-' is specified as the input file, read all text from stdin into a temporary file and use that as the entry point.
@@ -763,18 +765,23 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             nonBinLogArgs[0] = entryPointFilePath;
         }
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), RunCommandDefinition.VerbosityOption);
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
+            msbuildProperties,
+            CommonOptions.PropertiesOption,
+            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreateMSBuildTargetOption(),
+            definition.VerbosityOption);
 
         var command = new RunCommand(
             noBuild: noBuild,
             projectFileFullPath: projectFilePath,
             entryPointFileFullPath: entryPointFilePath,
             launchProfile: launchProfile,
-            noLaunchProfile: parseResult.HasOption(RunCommandDefinition.NoLaunchProfileOption),
-            noLaunchProfileArguments: parseResult.HasOption(RunCommandDefinition.NoLaunchProfileArgumentsOption),
-            noRestore: parseResult.HasOption(RunCommandDefinition.NoRestoreOption) || parseResult.HasOption(RunCommandDefinition.NoBuildOption),
-            noCache: parseResult.HasOption(RunCommandDefinition.NoCacheOption),
-            interactive: parseResult.GetValue(RunCommandDefinition.InteractiveOption),
+            noLaunchProfile: parseResult.HasOption(definition.NoLaunchProfileOption),
+            noLaunchProfileArguments: parseResult.HasOption(definition.NoLaunchProfileArgumentsOption),
+            noRestore: parseResult.HasOption(definition.NoRestoreOption) || parseResult.HasOption(definition.NoBuildOption),
+            noCache: parseResult.HasOption(definition.NoCacheOption),
+            interactive: parseResult.GetValue(definition.InteractiveOption),
             msbuildArgs: msbuildArgs,
             applicationArgs: args,
             readCodeFromStdin: readCodeFromStdin,
@@ -783,6 +790,23 @@ public static RunCommand FromParseResult(ParseResult parseResult)
         );
 
         return command;
+
+        bool UsingRunCommandShorthandProjectOption(ParseResult parseResult)
+        {
+            if (parseResult.HasOption(definition.PropertyOption) && parseResult.GetValue(definition.PropertyOption)!.Any())
+            {
+                var projVals = parseResult.GetRunCommandShorthandProjectValues();
+                if (projVals?.Any() is true)
+                {
+                    if (projVals.Count() != 1 || parseResult.HasOption(definition.ProjectOption))
+                    {
+                        throw new GracefulException(CliStrings.OnlyOneProjectAllowed);
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
     }
 
     public static int Run(ParseResult parseResult)
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
index bb5c2df0d273..3dd735e174c7 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -7,105 +7,115 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Run;
 
-internal static class RunCommandDefinition
+internal sealed class RunCommandDefinition : Command
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-run";
+    private const string Link = "https://aka.ms/dotnet-run";
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
+    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
 
-    public static readonly Option<string> ProjectOption = new("--project")
+    public readonly Option<string> ProjectOption = new("--project")
     {
         Description = CliCommandStrings.CmdProjectDescriptionFormat,
         HelpName = CliCommandStrings.CommandOptionProjectHelpName
     };
 
-    public static readonly Option<string> FileOption = new("--file")
+    public readonly Option<string> FileOption = new("--file")
     {
         Description = CliCommandStrings.CommandOptionFileDescription,
         HelpName = CliCommandStrings.CommandOptionFileHelpName,
     };
 
-    public static readonly Option<ReadOnlyDictionary<string, string>?> PropertyOption = CommonOptions.PropertiesOption;
+    public readonly Option<ReadOnlyDictionary<string, string>?> PropertyOption = CommonOptions.PropertiesOption;
 
-    public static readonly Option<string> LaunchProfileOption = new("--launch-profile", "-lp")
+    public readonly Option<string> LaunchProfileOption = new("--launch-profile", "-lp")
     {
         Description = CliCommandStrings.CommandOptionLaunchProfileDescription,
         HelpName = CliCommandStrings.CommandOptionLaunchProfileHelpName
     };
 
-    public static readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
+    public readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
     {
         Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
         Arity = ArgumentArity.Zero
     };
 
-    public static readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
+    public readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
     {
         Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
     };
 
-    public static readonly Option<bool> NoBuildOption = new("--no-build")
+    public const string NoBuildOptionName = "--no-build";
+
+    public readonly Option<bool> NoBuildOption = new(NoBuildOptionName)
     {
         Description = CliCommandStrings.CommandOptionNoBuildDescription,
         Arity = ArgumentArity.Zero
     };
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
-    public static readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+    public const string NoCacheOptionName = "--no-cache";
 
-    public static readonly Option<bool> NoCacheOption = new("--no-cache")
+    public readonly Option<bool> NoCacheOption = new(NoCacheOptionName)
     {
         Description = CliCommandStrings.CommandOptionNoCacheDescription,
         Arity = ArgumentArity.Zero,
     };
 
-    public static readonly Option SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option SelfContainedOption = CommonOptions.SelfContainedOption;
+
+    public readonly Option NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+
+    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
+
+    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
+
+    public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
 
-    public static readonly Option NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
 
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+    public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
 
-    public static readonly Argument<string[]> ApplicationArguments = new("applicationArguments")
+    public readonly Argument<string[]> ApplicationArguments = new("applicationArguments")
     {
         DefaultValueFactory = _ => [],
         Description = "Arguments passed to the application that is being run."
     };
 
-    public static Command Create()
+    public RunCommandDefinition()
+        : base("run", CliCommandStrings.RunAppFullName)
     {
-        Command command = new("run", CliCommandStrings.RunAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(ProjectOption);
-        command.Options.Add(FileOption);
-        command.Options.Add(PropertyOption);
-        command.Options.Add(LaunchProfileOption);
-        command.Options.Add(NoLaunchProfileOption);
-        command.Options.Add(NoBuildOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(NoCacheOption);
-        command.Options.Add(SelfContainedOption);
-        command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.CreateDisableBuildServersOption());
-        command.Options.Add(CommonOptions.CreateArtifactsPathOption());
-        command.Options.Add(CommonOptions.EnvOption);
-
-        command.Arguments.Add(ApplicationArguments);
-
-        return command;
+        this.DocsLink = Link;
+
+        Options.Add(ConfigurationOption);
+        Options.Add(FrameworkOption);
+        Options.Add(RuntimeOption);
+        Options.Add(ProjectOption);
+        Options.Add(FileOption);
+        Options.Add(PropertyOption);
+        Options.Add(LaunchProfileOption);
+        Options.Add(NoLaunchProfileOption);
+        Options.Add(NoBuildOption);
+        Options.Add(InteractiveOption);
+        Options.Add(NoRestoreOption);
+        Options.Add(NoCacheOption);
+        Options.Add(SelfContainedOption);
+        Options.Add(NoSelfContainedOption);
+        Options.Add(VerbosityOption);
+        Options.Add(ArchitectureOption);
+        Options.Add(OperatingSystemOption);
+        Options.Add(DisableBuildServersOption);
+        Options.Add(ArtifactsPathOption);
+        Options.Add(EnvOption);
+
+        Arguments.Add(ApplicationArguments);
     }
 }
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
index 1e25063f8c30..4c60bdb5ca23 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
@@ -7,15 +7,16 @@ namespace Microsoft.DotNet.Cli.Commands.Run;
 
 internal static class RunCommandParser
 {
-    private static readonly Command Command = SetAction(RunCommandDefinition.Create());
+    private static readonly RunCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command SetAction(Command command)
+    private static RunCommandDefinition CreateCommand()
     {
+        var command = new RunCommandDefinition();
         command.SetAction(RunCommand.Run);
         return command;
     }
diff --git a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
index 5e74f71bd7a5..bc144d235148 100644
--- a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
@@ -173,23 +173,6 @@ public static bool DiagOptionPrecedesSubcommand(this string[] args, string subCo
     public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =>
         parseResult.HasOption(CommonOptions.ArchitectureOption) && parseResult.HasOption(CommonOptions.OperatingSystemOption);
 
-    public static bool UsingRunCommandShorthandProjectOption(this ParseResult parseResult)
-    {
-        if (parseResult.HasOption(RunCommandDefinition.PropertyOption) && parseResult.GetValue(RunCommandDefinition.PropertyOption)!.Any())
-        {
-            var projVals = parseResult.GetRunCommandShorthandProjectValues();
-            if (projVals?.Any() is true)
-            {
-                if (projVals.Count() != 1 || parseResult.HasOption(RunCommandDefinition.ProjectOption))
-                {
-                    throw new GracefulException(CliStrings.OnlyOneProjectAllowed);
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-
     public static IEnumerable<string>? GetRunCommandShorthandProjectValues(this ParseResult parseResult)
     {
         var properties = GetRunPropertyOptions(parseResult, true);
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
index 1334303ac67b..73e20560298d 100644
--- a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
+++ b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
@@ -43,7 +43,20 @@ public void MsbuildInvocationIsCorrect(string[] args, string[] expectedArgs)
                     var command = RunCommand.FromArgs(args);
                     command.MSBuildArgs
                         .Should()
-                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments([.. ConstantRestoreArgs, .. expectedArgs, NuGetDisabledProperty ], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), RunCommandDefinition.VerbosityOption, CommonOptions.CreateNoLogoOption()));
+                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments(
+                        [
+                           .. ConstantRestoreArgs,
+                           .. expectedArgs,
+                           NuGetDisabledProperty
+                        ],
+                        options:
+                        [
+                            CommonOptions.PropertiesOption,
+                            CommonOptions.RestorePropertiesOption,
+                            CommonOptions.CreateMSBuildTargetOption(),
+                            CommonOptions.CreateVerbosityOption(),
+                            CommonOptions.CreateNoLogoOption()
+                        ]));
                 });
             }
             finally
diff --git a/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs b/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
index 06fffebf7df1..f45def4a88d4 100644
--- a/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
+++ b/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
@@ -173,7 +173,7 @@ public void FilePath(string? path, bool differentCasing)
                 .And.HaveStdErrContaining(string.Format(
                     CliCommandStrings.RunCommandExceptionNoProjects,
                     testInstance.Path,
-                    RunCommandDefinition.ProjectOption.Name));
+                    "--project"));
         }
     }
 
@@ -302,7 +302,7 @@ public void FilePath_DifferentCasing()
                 .And.HaveStdErrContaining(string.Format(
                     CliCommandStrings.RunCommandExceptionNoProjects,
                     testInstance.Path,
-                    RunCommandDefinition.ProjectOption.Name));
+                    "--project"));
         }
     }
 
@@ -587,7 +587,7 @@ public void ReadFromStdin_NoBuild()
         new DotnetCommand(Log, "run", "-", "--no-build")
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.NoBuildOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, "--no-build"));
     }
 
     [Fact]
@@ -596,7 +596,7 @@ public void ReadFromStdin_LaunchProfile()
         new DotnetCommand(Log, "run", "-", "--launch-profile=test")
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.LaunchProfileOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, "--launch-profile"));
     }
 
     /// <summary>
@@ -612,7 +612,7 @@ public void ReadFromStdin_AfterDoubleDash()
             .WithStandardInput("""Console.WriteLine("stdin code");""")
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.RunCommandExceptionNoProjects, testInstance.Path, RunCommandDefinition.ProjectOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.RunCommandExceptionNoProjects, testInstance.Path, "--project"));
     }
 
     /// <summary>
@@ -637,7 +637,7 @@ public void FolderPath(string? path)
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     /// <summary>
@@ -656,7 +656,7 @@ public void ProjectPath_DoesNotExist()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     /// <summary>
@@ -759,7 +759,7 @@ public void NonCsFileExtensionWithNoShebang(string fileName)
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     [Fact]
@@ -797,7 +797,7 @@ public void NoCode()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     /// <summary>
@@ -832,7 +832,7 @@ public void ClassLibrary_EntryPointFileDoesNotExist()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     /// <summary>
@@ -956,7 +956,7 @@ public void RunNestedProjectFile()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 workDir,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     /// <summary>
@@ -1397,7 +1397,7 @@ public void Arguments_Unrecognized()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandDefinition.ProjectOption.Name));
+                "--project"));
     }
 
     /// <summary>
@@ -3567,7 +3567,7 @@ public void UpToDate_InvalidOptions()
             .WithWorkingDirectory(testInstance.Path)
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.NoCacheOption.Name, RunCommandDefinition.NoBuildOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.CannotCombineOptions, "--no-cache", "--no-build"));
     }
 
     /// <summary>

From d6a7cf658d79dff0d35c677d82e81ec202be32f5 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 13:55:54 -0800
Subject: [PATCH 15/20] TargetPlatformOptions

---
 .../Commands/Build/BuildCommandDefinition.cs  |   8 +-
 .../Commands/Build/BuildCommandParser.cs      |   2 +
 .../Commands/Clean/CleanCommandDefinition.cs  |   2 +-
 .../Commands/Pack/PackCommandDefinition.cs    |   2 +-
 .../Publish/PublishCommandDefinition.cs       |   8 +-
 .../Commands/Publish/PublishCommandParser.cs  |   2 +
 .../Restore/RestoreCommandDefinition.cs       |  26 ++--
 .../Commands/Run/RunCommandDefinition.cs      |  10 +-
 .../dotnet/Commands/Run/RunCommandParser.cs   |   2 +
 .../Commands/Test/MTP/ValidationUtility.cs    |   6 +-
 ...mandDefinition.MicrosoftTestingPlatform.cs |  10 +-
 .../Test/TestCommandDefinition.VSTest.cs      |  10 +-
 .../Commands/Test/TestCommandDefinition.cs    |   2 +
 .../dotnet/Commands/Test/TestCommandParser.cs |   3 +
 .../Common/Store/StoreCommandDefinition.cs    |   2 +-
 src/Cli/dotnet/CommonOptions.cs               | 101 -------------
 .../Extensions/ParseResultExtensions.cs       |   3 -
 .../ShellShim/ShellShimTemplateFinder.cs      |   2 +-
 src/Cli/dotnet/TargetPlatformOptions.cs       | 136 ++++++++++++++++++
 src/Cli/dotnet/Telemetry/TelemetryFilter.cs   |   4 +-
 ...tBuildsAndRunsTestsWithDifferentOptions.cs |  18 +--
 21 files changed, 183 insertions(+), 176 deletions(-)
 create mode 100644 src/Cli/dotnet/TargetPlatformOptions.cs

diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index e47c11141c50..3776d646ae56 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -46,7 +46,7 @@ internal sealed class BuildCommandDefinition : Command
 
     public readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.BuildRuntimeOptionDescription);
 
     public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
 
@@ -63,8 +63,6 @@ internal sealed class BuildCommandDefinition : Command
     public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
     public readonly Option<bool> DebugOption = CommonOptions.DebugOption;
     public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
-    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
     public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
     public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
     public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
@@ -80,7 +78,6 @@ public BuildCommandDefinition()
         ImplicitRestoreOptions.AddTo(Options);
         Options.Add(FrameworkOption);
         Options.Add(ConfigurationOption);
-        Options.Add(RuntimeOption);
         Options.Add(VersionSuffixOption);
         Options.Add(NoRestoreOption);
         Options.Add(InteractiveOption);
@@ -93,8 +90,7 @@ public BuildCommandDefinition()
         Options.Add(NoLogoOption);
         Options.Add(SelfContainedOption);
         Options.Add(NoSelfContainedOption);
-        Options.Add(ArchitectureOption);
-        Options.Add(OperatingSystemOption);
+        TargetPlatformOptions.AddTo(Options);
         Options.Add(DisableBuildServersOption);
         Options.Add(TargetOption);
         Options.Add(GetPropertyOption);
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
index 3264feff6496..490189bac558 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Build;
 
@@ -18,6 +19,7 @@ private static BuildCommandDefinition CreateCommand()
     {
         var command = new BuildCommandDefinition();
         command.SetAction(BuildCommand.Run);
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
index 58410ea9c14b..272a005d7b30 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
@@ -35,7 +35,7 @@ internal sealed class CleanCommandDefinition : Command
 
     public readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.CreateVerbosityOption(Utils.VerbosityOptions.normal);
 
-    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription);
+    public readonly Option<string> RuntimeOption = TargetPlatformOptions.CreateRuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription);
     public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
     public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
     public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 8b17d5525f0a..66236bfe5adb 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -70,7 +70,7 @@ internal sealed class PackCommandDefinition : Command
     public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
     public readonly Option<string[]?> GetResultOutputFileOption = CommonOptions.CreateGetResultOutputFileOption();
     public readonly Option<bool> NoDependenciesOption = RestoreCommandDefinition.CreateNoDependenciesOption(showHelp: false);
-    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+    public readonly Option<string> RuntimeOption = TargetPlatformOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
 
     public readonly Option<NuGetVersion> VersionOption = new Option<NuGetVersion>("--version")
     {
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index b186d0ef655c..815514e5eb63 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -48,7 +48,7 @@ internal sealed class PublishCommandDefinition : Command
 
     public readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.PublishRuntimeOptionDescription);
 
     public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
 
@@ -61,8 +61,6 @@ internal sealed class PublishCommandDefinition : Command
     public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
     public readonly Option<string> VersionSuffixOption = CommonOptions.CreateVersionSuffixOption();
     public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
-    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
     public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
     public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
     public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
@@ -85,14 +83,12 @@ public PublishCommandDefinition()
         Options.Add(NoSelfContainedOption);
         Options.Add(NoLogoOption);
         Options.Add(FrameworkOption);
-        Options.Add(RuntimeOption);
         Options.Add(ConfigurationOption);
         Options.Add(VersionSuffixOption);
         Options.Add(InteractiveOption);
         Options.Add(NoRestoreOption);
         Options.Add(VerbosityOption);
-        Options.Add(ArchitectureOption);
-        Options.Add(OperatingSystemOption);
+        TargetPlatformOptions.AddTo(Options);
         Options.Add(DisableBuildServersOption);
         Options.Add(TargetOption);
         Options.Add(GetPropertyOption);
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
index fbe4e55e2955..3ef720071949 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Publish;
 
@@ -18,6 +19,7 @@ private static PublishCommandDefinition CreateCommand()
     {
         var command = new PublishCommandDefinition();
         command.SetAction(PublishCommand.Run);
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
index a0b6a2f48636..89ea3794459a 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -24,7 +24,9 @@ internal sealed class RestoreCommandDefinition : Command
     public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
     public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
-    public readonly Option<IEnumerable<string>> RuntimeOption = CreateRuntimeOption(showHelp: true, useShortOptions: true);
+
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CreateRuntimeOption());
+
     public readonly Option<bool> NoDependenciesOption = CreateNoDependenciesOption(showHelp: true);
     public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
     public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
@@ -53,8 +55,6 @@ internal sealed class RestoreCommandDefinition : Command
         Arity = ArgumentArity.Zero
     }.ForwardAs("-property:RestoreForceEvaluate=true");
 
-    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
     public readonly Option<string[]?> GetPropertyOption = CommonOptions.CreateGetPropertyOption();
     public readonly Option<string[]?> GetItemOption = CommonOptions.CreateGetItemOption();
     public readonly Option<string[]?> GetTargetResultOption = CommonOptions.CreateGetTargetResultOption();
@@ -70,7 +70,6 @@ public RestoreCommandDefinition()
 
         ImplicitRestoreOptions.AddTo(Options);
 
-        Options.Add(RuntimeOption);
         Options.Add(NoDependenciesOption);
         Options.Add(VerbosityOption);
         Options.Add(InteractiveOption);
@@ -82,8 +81,8 @@ public RestoreCommandDefinition()
         Options.Add(TargetOption);
         Options.Add(NoLogoOption);
 
-        Options.Add(ArchitectureOption);
-        Options.Add(OperatingSystemOption);
+        TargetPlatformOptions.AddTo(Options);
+
         Options.Add(GetPropertyOption);
         Options.Add(GetItemOption);
         Options.Add(GetTargetResultOption);
@@ -113,23 +112,17 @@ public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
         return $"-property:RuntimeIdentifiers={string.Join("%3B", convertedRids)}";
     }
 
-    private static Option<IEnumerable<string>> CreateRuntimeOption(bool showHelp, bool useShortOptions)
+    private static Option<IEnumerable<string>> CreateRuntimeOption()
     {
-        Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime")
+        Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime", "-r")
         {
             Description = CliCommandStrings.CmdRuntimeOptionDescription,
             HelpName = CliCommandStrings.CmdRuntimeOption,
-            Hidden = !showHelp,
             IsDynamic = true
         }.ForwardAsSingle(RestoreRuntimeArgFunc)
          .AllowSingleArgPerToken()
          .AddCompletions(CliCompletion.RunTimesFromProjectFile);
 
-        if (useShortOptions)
-        {
-            runtimeOption.Aliases.Add("-r");
-        }
-
         return runtimeOption;
     }
 
@@ -141,6 +134,7 @@ public static Option<bool> CreateNoDependenciesOption(bool showHelp)
             Hidden = !showHelp
         }.ForwardAs("-property:RestoreRecursive=false");
 
-    public static Option<string[]> CreateTargetOption()
-        => CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
+    public static Option<string[]> CreateTargetOption() => CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
+
+
 }
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
index 3dd735e174c7..301eb0b965d0 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -15,7 +15,7 @@ internal sealed class RunCommandDefinition : Command
 
     public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
 
-    public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.RunRuntimeOptionDescription);
 
     public readonly Option<string> ProjectOption = new("--project")
     {
@@ -74,10 +74,6 @@ internal sealed class RunCommandDefinition : Command
 
     public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-
-    public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-
     public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
 
     public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
@@ -97,7 +93,6 @@ public RunCommandDefinition()
 
         Options.Add(ConfigurationOption);
         Options.Add(FrameworkOption);
-        Options.Add(RuntimeOption);
         Options.Add(ProjectOption);
         Options.Add(FileOption);
         Options.Add(PropertyOption);
@@ -110,8 +105,7 @@ public RunCommandDefinition()
         Options.Add(SelfContainedOption);
         Options.Add(NoSelfContainedOption);
         Options.Add(VerbosityOption);
-        Options.Add(ArchitectureOption);
-        Options.Add(OperatingSystemOption);
+        TargetPlatformOptions.AddTo(Options);
         Options.Add(DisableBuildServersOption);
         Options.Add(ArtifactsPathOption);
         Options.Add(EnvOption);
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
index 4c60bdb5ca23..da64925a6c9f 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Run;
 
@@ -18,6 +19,7 @@ private static RunCommandDefinition CreateCommand()
     {
         var command = new RunCommandDefinition();
         command.SetAction(RunCommand.Run);
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs b/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs
index d6630475269f..6751f5c2e3d4 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs
@@ -41,11 +41,11 @@ void ValidateOptionsIrrelevantToModulesFilter(ParseResult parseResult)
                 return;
             }
 
-            if (parseResult.HasOption(definition.ArchitectureOption) ||
+            if (parseResult.HasOption(definition.TargetPlatformOptions.ArchitectureOption) ||
                 parseResult.HasOption(definition.ConfigurationOption) ||
                 parseResult.HasOption(definition.FrameworkOption) ||
-                parseResult.HasOption(definition.OperatingSystemOption) ||
-                parseResult.HasOption(definition.RuntimeOption))
+                parseResult.HasOption(definition.TargetPlatformOptions.OperatingSystemOption) ||
+                parseResult.HasOption(definition.TargetPlatformOptions.RuntimeOption))
             {
                 throw new GracefulException(CliCommandStrings.CmdOptionCannotBeUsedWithTestModulesDescription);
             }
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
index 7ebb96cfddd9..ab4be4eb3ee0 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
@@ -77,16 +77,10 @@ public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHel
             HelpName = CliCommandStrings.CmdNumberName
         };
 
-        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-
         public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
 
         public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
 
-        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-
-        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
-
         public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
         public readonly Option<bool> NoBuildOption = new("--no-build")
@@ -147,13 +141,11 @@ public MicrosoftTestingPlatform()
             Options.Add(DiagnosticOutputDirectoryOption);
             Options.Add(MaxParallelTestModulesOption);
             Options.Add(MinimumExpectedTestsOption);
-            Options.Add(ArchitectureOption);
             Options.Add(EnvOption);
             Options.Add(PropertiesOption);
             Options.Add(ConfigurationOption);
             Options.Add(FrameworkOption);
-            Options.Add(OperatingSystemOption);
-            Options.Add(RuntimeOption);
+            TargetPlatformOptions.AddTo(Options);
             Options.Add(VerbosityOption);
             Options.Add(NoRestoreOption);
             Options.Add(NoBuildOption);
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
index 66c17c83348e..b311c0ce0df6 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
@@ -121,16 +121,10 @@ public sealed class VSTest : TestCommandDefinition
 
         public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
 
-        public readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.TestRuntimeOptionDescription);
-
         public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
         public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
-        public readonly Option<string> ArchitectureOption = CommonOptions.ArchitectureOption;
-
-        public readonly Option<string> OperatingSystemOption = CommonOptions.OperatingSystemOption;
-
         public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
 
         public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
@@ -189,12 +183,10 @@ public VSTest()
             Options.Add(NoLogoOption);
             Options.Add(ConfigurationOption);
             Options.Add(FrameworkOption);
-            Options.Add(RuntimeOption);
             Options.Add(NoRestoreOption);
             Options.Add(InteractiveOption);
             Options.Add(VerbosityOption);
-            Options.Add(ArchitectureOption);
-            Options.Add(OperatingSystemOption);
+            TargetPlatformOptions.AddTo(Options);
             Options.Add(PropertiesOption);
             Options.Add(DisableBuildServersOption);
             Options.Add(VsTestTargetOption);
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
index 6915f7991add..137a1e0c422c 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -13,6 +13,8 @@ internal abstract partial class TestCommandDefinition : Command
 {
     private const string Link = "https://aka.ms/dotnet-test";
 
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.TestRuntimeOptionDescription);
+
     public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
 
     public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
index 19a435e0007c..427f86d9fcb3 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.DotNet.Cli.CommandLine;
 using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
@@ -18,6 +19,8 @@ private static TestCommandDefinition CreateCommand()
     {
         var command = TestCommandDefinition.Create();
 
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
+
         switch (command)
         {
             case TestCommandDefinition.VSTest vs:
diff --git a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
index 71e9b5d7bdd4..74d694c246f2 100644
--- a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
@@ -68,7 +68,7 @@ internal static class StoreCommandDefinition
     }.ForwardAs("-property:CreateProfilingSymbols=false");
 
     public static readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription);
-    public static readonly Option<string> RuntimeOption = CommonOptions.CreateRuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription);
+    public static readonly Option<string> RuntimeOption = TargetPlatformOptions.CreateRuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription);
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
     public static readonly Option<bool> UseCurrentRuntimeOption = CommonOptions.CreateUseCurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription);
     public static readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 5c045ba09d44..240bcea05e20 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -3,7 +3,6 @@
 
 using System.Collections.ObjectModel;
 using System.CommandLine;
-using System.CommandLine.Completions;
 using System.CommandLine.Parsing;
 using System.CommandLine.StaticCompletions;
 using Microsoft.DotNet.Cli.CommandLine;
@@ -189,27 +188,6 @@ public static Option<string> CreateArtifactsPathOption() =>
             HelpName = CliStrings.ArtifactsPathArgumentName
         }.ForwardAsSingle(o => $"--property:ArtifactsPath={CommandDirectoryContext.GetFullPath(o)}");
 
-    private static readonly string RuntimeArgName = CliStrings.RuntimeIdentifierArgumentName;
-    public static IEnumerable<string> RuntimeArgFunc(string rid)
-    {
-        if (GetArchFromRid(rid) == "amd64")
-        {
-            rid = GetOsFromRid(rid) + "-x64";
-        }
-        return [$"--property:RuntimeIdentifier={rid}", "--property:_CommandLineDefinedRuntimeIdentifier=true"];
-    }
-
-    public const string RuntimeOptionName = "--runtime";
-
-    public static Option<string> CreateRuntimeOption(string description) =>
-        new Option<string>(RuntimeOptionName, "-r")
-        {
-            HelpName = RuntimeArgName,
-            Description = description,
-            IsDynamic = true
-        }.ForwardAsMany(RuntimeArgFunc!)
-        .AddCompletions(CliCompletion.RunTimesFromProjectFile);
-
     public static Option<bool> CreateUseCurrentRuntimeOption(string description) =>
         new Option<bool>("--use-current-runtime", "--ucr")
         {
@@ -295,20 +273,6 @@ public static Option<bool> CreateDisableBuildServersOption() =>
         }
         .ForwardIfEnabled(["--property:UseRazorBuildServer=false", "--property:UseSharedCompilation=false", "/nodeReuse:false"]);
 
-    public static Option<string> ArchitectureOption =
-        new Option<string>("--arch", "-a")
-        {
-            Description = CliStrings.ArchitectureOptionDescription,
-            HelpName = CliStrings.ArchArgumentName
-        }.SetForwardingFunction(ResolveArchOptionToRuntimeIdentifier);
-
-    public static Option<string> OperatingSystemOption =
-        new Option<string>("--os")
-        {
-            Description = CliStrings.OperatingSystemOptionDescription,
-            HelpName = CliStrings.OSArgumentName
-        }.SetForwardingFunction(ResolveOsOptionToRuntimeIdentifier);
-
     public static Option<bool> DebugOption = new("--debug")
     {
         Arity = ArgumentArity.Zero,
@@ -420,71 +384,6 @@ public static void ValidateSelfContainedOptions(bool hasSelfContainedOption, boo
             throw new GracefulException(CliStrings.SelfContainAndNoSelfContainedConflict);
         }
     }
-
-    internal static IEnumerable<string> ResolveArchOptionToRuntimeIdentifier(string? arg, ParseResult parseResult)
-    {
-        if (parseResult.GetResult(RuntimeOptionName) is not null)
-        {
-            throw new GracefulException(CliStrings.CannotSpecifyBothRuntimeAndArchOptions);
-        }
-
-        if (parseResult.BothArchAndOsOptionsSpecified())
-        {
-            // ResolveOsOptionToRuntimeIdentifier handles resolving the RID when both arch and os are specified
-            return [];
-        }
-
-        return ResolveRidShorthandOptions(null, arg);
-    }
-
-    internal static IEnumerable<string> ResolveOsOptionToRuntimeIdentifier(string? arg, ParseResult parseResult)
-    {
-        if (parseResult.GetResult(RuntimeOptionName) is not null)
-        {
-            throw new GracefulException(CliStrings.CannotSpecifyBothRuntimeAndOsOptions);
-        }
-
-        var arch = parseResult.BothArchAndOsOptionsSpecified() ? parseResult.GetValue(ArchitectureOption) : null;
-        return ResolveRidShorthandOptions(arg, arch);
-    }
-
-    private static IEnumerable<string> ResolveRidShorthandOptions(string? os, string? arch) =>
-        [$"--property:RuntimeIdentifier={ResolveRidShorthandOptionsToRuntimeIdentifier(os, arch)}"];
-
-    internal static string ResolveRidShorthandOptionsToRuntimeIdentifier(string? os, string? arch)
-    {
-        var currentRid = GetCurrentRuntimeId();
-        arch = arch == "amd64" ? "x64" : arch;
-        os = string.IsNullOrEmpty(os) ? GetOsFromRid(currentRid) : os;
-        arch = string.IsNullOrEmpty(arch) ? GetArchFromRid(currentRid) : arch;
-        return $"{os}-{arch}";
-    }
-
-    public static string GetCurrentRuntimeId()
-    {
-        // Get the dotnet directory, while ignoring custom msbuild resolvers
-        string? dotnetRootPath = NativeWrapper.EnvironmentProvider.GetDotnetExeDirectory(key =>
-            key.Equals("DOTNET_MSBUILD_SDK_RESOLVER_CLI_DIR", StringComparison.InvariantCultureIgnoreCase)
-                ? null
-                : Environment.GetEnvironmentVariable(key));
-        var ridFileName = "NETCoreSdkRuntimeIdentifierChain.txt";
-        var sdkPath = dotnetRootPath is not null ? Path.Combine(dotnetRootPath, "sdk") : "sdk";
-
-        // When running under test the Product.Version might be empty or point to version not installed in dotnetRootPath.
-        string runtimeIdentifierChainPath = string.IsNullOrEmpty(Product.Version) || !Directory.Exists(Path.Combine(sdkPath, Product.Version)) ?
-            Path.Combine(Directory.GetDirectories(sdkPath)[0], ridFileName) :
-            Path.Combine(sdkPath, Product.Version, ridFileName);
-        string[] currentRuntimeIdentifiers = File.Exists(runtimeIdentifierChainPath) ? [.. File.ReadAllLines(runtimeIdentifierChainPath).Where(l => !string.IsNullOrEmpty(l))] : [];
-        if (currentRuntimeIdentifiers == null || !currentRuntimeIdentifiers.Any() || !currentRuntimeIdentifiers[0].Contains("-"))
-        {
-            throw new GracefulException(CliStrings.CannotResolveRuntimeIdentifier);
-        }
-        return currentRuntimeIdentifiers[0]; // First rid is the most specific (ex win-x64)
-    }
-
-    private static string GetOsFromRid(string rid) => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
-
-    private static string GetArchFromRid(string rid) => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
 }
 
 
diff --git a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
index bc144d235148..9ee171d6868c 100644
--- a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
@@ -170,9 +170,6 @@ public static bool DiagOptionPrecedesSubcommand(this string[] args, string subCo
         _ => parseResult.GetResult(Parser.DotnetSubCommand)?.GetValueOrDefault<string>()
     };
 
-    public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =>
-        parseResult.HasOption(CommonOptions.ArchitectureOption) && parseResult.HasOption(CommonOptions.OperatingSystemOption);
-
     public static IEnumerable<string>? GetRunCommandShorthandProjectValues(this ParseResult parseResult)
     {
         var properties = GetRunPropertyOptions(parseResult, true);
diff --git a/src/Cli/dotnet/ShellShim/ShellShimTemplateFinder.cs b/src/Cli/dotnet/ShellShim/ShellShimTemplateFinder.cs
index 935f9e59098b..c416292bca02 100644
--- a/src/Cli/dotnet/ShellShim/ShellShimTemplateFinder.cs
+++ b/src/Cli/dotnet/ShellShim/ShellShimTemplateFinder.cs
@@ -42,7 +42,7 @@ public async Task<string> ResolveAppHostSourceDirectoryAsync(string archOption,
         }
         else
         {
-            rid = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(null, archOption);
+            rid = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(os: null, archOption);
         }
 
         if (!validRids.Contains(rid))
diff --git a/src/Cli/dotnet/TargetPlatformOptions.cs b/src/Cli/dotnet/TargetPlatformOptions.cs
new file mode 100644
index 000000000000..6f61463751e8
--- /dev/null
+++ b/src/Cli/dotnet/TargetPlatformOptions.cs
@@ -0,0 +1,136 @@
+// 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 Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Utils;
+using System.CommandLine.StaticCompletions;
+
+namespace Microsoft.DotNet.Cli;
+
+internal readonly struct TargetPlatformOptions
+{
+    public const string RuntimeOptionName = "--runtime";
+
+    public readonly Option RuntimeOption;
+
+    public readonly Option<string> ArchitectureOption = new("--arch", "-a")
+    {
+        Description = CliStrings.ArchitectureOptionDescription,
+        HelpName = CliStrings.ArchArgumentName
+    };
+
+    public readonly Option<string> OperatingSystemOption = new("--os")
+    {
+        Description = CliStrings.OperatingSystemOptionDescription,
+        HelpName = CliStrings.OSArgumentName
+    };
+
+    public TargetPlatformOptions(Option runtimeOption)
+    {
+        RuntimeOption = runtimeOption;
+        ArchitectureOption.SetForwardingFunction(ResolveArchOptionToRuntimeIdentifier);
+        OperatingSystemOption.SetForwardingFunction(ResolveOsOptionToRuntimeIdentifier);
+    }
+
+    public TargetPlatformOptions(string runtimeOptionDescription)
+        : this(CreateRuntimeOption(runtimeOptionDescription))
+    {
+    }
+
+    public void AddTo(IList<Option> options)
+    {
+        options.Add(RuntimeOption);
+        options.Add(ArchitectureOption);
+        options.Add(OperatingSystemOption);
+    }
+
+    public static IEnumerable<string> RuntimeArgFunc(string rid)
+    {
+        if (GetArchFromRid(rid) == "amd64")
+        {
+            rid = GetOsFromRid(rid) + "-x64";
+        }
+        return [$"--property:RuntimeIdentifier={rid}", "--property:_CommandLineDefinedRuntimeIdentifier=true"];
+    }
+
+    public static Option<string> CreateRuntimeOption(string description) =>
+        new Option<string>(RuntimeOptionName, "-r")
+        {
+            HelpName = CliStrings.RuntimeIdentifierArgumentName,
+            Description = description,
+            IsDynamic = true
+        }.ForwardAsMany(RuntimeArgFunc!);
+
+    public IEnumerable<string> ResolveArchOptionToRuntimeIdentifier(string? arg, ParseResult parseResult)
+    {
+        if (parseResult.HasOption(RuntimeOption))
+        {
+            throw new GracefulException(CliStrings.CannotSpecifyBothRuntimeAndArchOptions);
+        }
+
+        if (parseResult.HasOption(ArchitectureOption) && parseResult.HasOption(OperatingSystemOption))
+        {
+            // ResolveOsOptionToRuntimeIdentifier handles resolving the RID when both arch and os are specified
+            return [];
+        }
+
+        return ResolveRidShorthandOptions(os: null, arch: arg);
+    }
+
+    public IEnumerable<string> ResolveOsOptionToRuntimeIdentifier(string? arg, ParseResult parseResult)
+    {
+        if (parseResult.HasOption(RuntimeOption))
+        {
+            throw new GracefulException(CliStrings.CannotSpecifyBothRuntimeAndOsOptions);
+        }
+
+        var arch = parseResult.HasOption(ArchitectureOption) && parseResult.HasOption(OperatingSystemOption)
+            ? parseResult.GetValue(ArchitectureOption)
+            : null;
+
+        return ResolveRidShorthandOptions(arg, arch);
+    }
+
+    private static IEnumerable<string> ResolveRidShorthandOptions(string? os, string? arch) =>
+        [$"--property:RuntimeIdentifier={ResolveRidShorthandOptionsToRuntimeIdentifier(os, arch)}"];
+
+    public static string ResolveRidShorthandOptionsToRuntimeIdentifier(string? os, string? arch)
+    {
+        var currentRid = GetCurrentRuntimeId();
+        arch = arch == "amd64" ? "x64" : arch;
+        os = string.IsNullOrEmpty(os) ? GetOsFromRid(currentRid) : os;
+        arch = string.IsNullOrEmpty(arch) ? GetArchFromRid(currentRid) : arch;
+        return $"{os}-{arch}";
+    }
+
+    public static string GetCurrentRuntimeId()
+    {
+        // Get the dotnet directory, while ignoring custom msbuild resolvers
+        string? dotnetRootPath = NativeWrapper.EnvironmentProvider.GetDotnetExeDirectory(key =>
+            key.Equals("DOTNET_MSBUILD_SDK_RESOLVER_CLI_DIR", StringComparison.InvariantCultureIgnoreCase)
+                ? null
+                : Environment.GetEnvironmentVariable(key));
+        var ridFileName = "NETCoreSdkRuntimeIdentifierChain.txt";
+        var sdkPath = dotnetRootPath is not null ? Path.Combine(dotnetRootPath, "sdk") : "sdk";
+
+        // When running under test the Product.Version might be empty or point to version not installed in dotnetRootPath.
+        string runtimeIdentifierChainPath = string.IsNullOrEmpty(Product.Version) || !Directory.Exists(Path.Combine(sdkPath, Product.Version)) ?
+            Path.Combine(Directory.GetDirectories(sdkPath)[0], ridFileName) :
+            Path.Combine(sdkPath, Product.Version, ridFileName);
+        string[] currentRuntimeIdentifiers = File.Exists(runtimeIdentifierChainPath) ? [.. File.ReadAllLines(runtimeIdentifierChainPath).Where(l => !string.IsNullOrEmpty(l))] : [];
+        if (currentRuntimeIdentifiers == null || !currentRuntimeIdentifiers.Any() || !currentRuntimeIdentifiers[0].Contains("-"))
+        {
+            throw new GracefulException(CliStrings.CannotResolveRuntimeIdentifier);
+        }
+        return currentRuntimeIdentifiers[0]; // First rid is the most specific (ex win-x64)
+    }
+
+    private static string GetOsFromRid(string rid)
+        => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
+
+    private static string GetArchFromRid(string rid)
+        => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
+}
+
+
diff --git a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
index cbf561e0dc73..3bd20c787b33 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
@@ -110,7 +110,7 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["build", "publish"],
-            optionsToLog: [ CommonOptions.FrameworkOptionName, CommonOptions.RuntimeOptionName, CommonOptions.ConfigurationOptionName ]
+            optionsToLog: [ CommonOptions.FrameworkOptionName, TargetPlatformOptions.RuntimeOptionName, CommonOptions.ConfigurationOptionName ]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
@@ -130,7 +130,7 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["publish"],
-            optionsToLog: [CommonOptions.RuntimeOptionName]
+            optionsToLog: [TargetPlatformOptions.RuntimeOptionName]
         ),
         new AllowListToSendVerbSecondVerbFirstArgument(["workload", "tool", "new"]),
     ];
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
index 9a405e23741b..d8ba31c264eb 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsWithDifferentOptions.cs
@@ -224,7 +224,7 @@ public void RunTestProjectWithArchOption_ShouldReturnExitCodeSuccess(string conf
                                     .Execute("--arch", arch,
                                              "--configuration", configuration);
 
-            string runtime = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
+            string runtime = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -265,11 +265,11 @@ public void RunTestProjectSolutionWithRuntimeOption_ShouldReturnExitCodeSuccess(
         {
             TestAsset testInstance = _testAssetsManager.CopyTestAsset("TestProjectWithTests", Guid.NewGuid().ToString()).WithSource();
 
-            string runtime = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, "x64");
+            string runtime = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, "x64");
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.RuntimeOptionName, runtime,
+                                    .Execute("--runtime", runtime,
                                              "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
@@ -285,11 +285,11 @@ public void RunTestProjectSolutionWithArchAndRuntimeOptions_ShouldReturnExitCode
             TestAsset testInstance = _testAssetsManager.CopyTestAsset("TestProjectWithTests", Guid.NewGuid().ToString()).WithSource();
 
             var arch = RuntimeInformation.ProcessArchitecture.Equals(Architecture.Arm64) ? "arm64" : Environment.Is64BitOperatingSystem ? "x64" : "x86";
-            string runtime = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
+            string runtime = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.RuntimeOptionName, runtime,
+                                    .Execute("--runtime", runtime,
                                             "--arch", arch,
                                             "--configuration", configuration);
 
@@ -303,11 +303,11 @@ public void RunTestProjectSolutionWithOSOption_ShouldReturnExitCodeSuccess(strin
         {
             TestAsset testInstance = _testAssetsManager.CopyTestAsset("TestProjectWithTests", Guid.NewGuid().ToString()).WithSource();
 
-            string runtime = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, string.Empty);
+            string runtime = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, string.Empty);
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.OperatingSystemOption.Name, runtime.Split('-')[0],
+                                    .Execute("--os", runtime.Split('-')[0],
                                             "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
@@ -323,11 +323,11 @@ public void RunTestProjectSolutionWithArchAndOSOptions_ShouldReturnExitCodeSucce
             TestAsset testInstance = _testAssetsManager.CopyTestAsset("TestProjectWithTests", Guid.NewGuid().ToString()).WithSource();
 
             var arch = RuntimeInformation.ProcessArchitecture.Equals(Architecture.Arm64) ? "arm64" : Environment.Is64BitOperatingSystem ? "x64" : "x86";
-            string runtime = CommonOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
+            string runtime = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.OperatingSystemOption.Name, runtime.Split('-')[0],
+                                    .Execute("--os", runtime.Split('-')[0],
                                             "--arch", arch,
                                             "--configuration", configuration);
 

From ae414d7ba26009f604f9d09d8e70c4b88caaaa2f Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 14:09:12 -0800
Subject: [PATCH 16/20] ReleasePropertyProjectLocator refactoring

---
 .../Commands/Build/BuildCommandDefinition.cs  |  2 +-
 src/Cli/dotnet/Commands/Pack/PackCommand.cs   |  2 +-
 .../Commands/Pack/PackCommandDefinition.cs    |  2 +-
 .../dotnet/Commands/Publish/PublishCommand.cs |  2 +-
 .../Publish/PublishCommandDefinition.cs       |  2 +-
 .../Commands/Run/RunCommandDefinition.cs      |  2 +-
 ...mandDefinition.MicrosoftTestingPlatform.cs |  2 +-
 .../Test/TestCommandDefinition.VSTest.cs      |  2 +-
 src/Cli/dotnet/CommonOptions.cs               |  5 +-
 .../dotnet/ReleasePropertyProjectLocator.cs   | 66 +++++++------------
 .../Test/GivenDotnetTestBuildsAndRunsTests.cs |  2 +-
 ...etTestBuildsAndRunsTestsForMultipleTFMs.cs |  2 +-
 12 files changed, 36 insertions(+), 55 deletions(-)

diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index 3776d646ae56..b870c9bc075c 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -40,7 +40,7 @@ internal sealed class BuildCommandDefinition : Command
 
     public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
     public readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
 
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommand.cs b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
index e4550abc2e67..2f38f51d72ff 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommand.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
@@ -67,7 +67,7 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
             msbuildPath,
             transformer: (msbuildArgs) =>
             {
-                ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
+                ReleasePropertyProjectLocator projectLocator = new(parseResult.GetValue(CommonOptions.PropertiesOption), MSBuildPropertyNames.PACK_RELEASE,
                     new ReleasePropertyProjectLocator.DependentCommandOptions(
                             nonBinLogArgs,
                             parseResult.HasOption(definition.ConfigurationOption) ? parseResult.GetValue(definition.ConfigurationOption) : null
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
index 66236bfe5adb..1f321198a7c0 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -53,7 +53,7 @@ internal sealed class PackCommandDefinition : Command
 
     public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
     public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
 
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
index 467b526b0a96..abf792bee5bd 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
@@ -77,7 +77,7 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                         parseResult.HasOption(definition.ConfigurationOption) ? parseResult.GetValue(definition.ConfigurationOption) : null,
                         parseResult.HasOption(definition.FrameworkOption) ? parseResult.GetValue(definition.FrameworkOption) : null
                     );
-                var projectLocator = new ReleasePropertyProjectLocator(parseResult, MSBuildPropertyNames.PUBLISH_RELEASE, options);
+                var projectLocator = new ReleasePropertyProjectLocator(parseResult.GetValue(CommonOptions.PropertiesOption), MSBuildPropertyNames.PUBLISH_RELEASE, options);
                 var releaseModeProperties = projectLocator.GetCustomDefaultConfigurationValueIfSpecified();
                 return msbuildArgs.CloneWithAdditionalProperties(releaseModeProperties);
             }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index 815514e5eb63..23f60b4e59e5 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -42,7 +42,7 @@ internal sealed class PublishCommandDefinition : Command
 
     public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
     public readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
 
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
index 301eb0b965d0..8ac053b536e3 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -56,7 +56,7 @@ internal sealed class RunCommandDefinition : Command
         Arity = ArgumentArity.Zero
     };
 
-    public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
     public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
index ab4be4eb3ee0..90051e54ab20 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
@@ -81,7 +81,7 @@ public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHel
 
         public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
 
-        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
         public readonly Option<bool> NoBuildOption = new("--no-build")
         {
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
index b311c0ce0df6..aba5e25f6bab 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
@@ -121,7 +121,7 @@ public sealed class VSTest : TestCommandDefinition
 
         public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
 
-        public readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
         public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 240bcea05e20..18c9296b91de 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -28,7 +28,7 @@ internal static class CommonOptions
             Arity = ArgumentArity.ZeroOrMore,
             CustomParser = ParseMSBuildTokensIntoDictionary
         }.ForwardAsMSBuildProperty()
-        .AllowSingleArgPerToken();
+         .AllowSingleArgPerToken();
 
     /// <summary>
     /// Sets MSBuild Global Property values that are only used during Restore (implicit or explicit)
@@ -223,13 +223,12 @@ public static Argument<string> DefaultToCurrentDirectory(this Argument<string> a
         return arg;
     }
 
-    public static Option<bool> NoRestoreOption = new Option<bool>("--no-restore")
+    public static Option<bool> CreateNoRestoreOption() => new Option<bool>("--no-restore")
     {
         Description = CliStrings.NoRestoreDescription,
         Arity = ArgumentArity.Zero
     }.ForwardAs("-restore:false");
 
-
     public static Option<bool> RestoreOption = new Option<bool>("--restore", "-restore")
     {
         Description = "Restore the project before building it. This is the default behavior.",
diff --git a/src/Cli/dotnet/ReleasePropertyProjectLocator.cs b/src/Cli/dotnet/ReleasePropertyProjectLocator.cs
index fba8ee42a7c3..582eaf14d36d 100644
--- a/src/Cli/dotnet/ReleasePropertyProjectLocator.cs
+++ b/src/Cli/dotnet/ReleasePropertyProjectLocator.cs
@@ -20,38 +20,23 @@ namespace Microsoft.DotNet.Cli;
 /// Because of this, it is 'impossible' for the project file to correctly influence the value of Configuration.
 /// This class allows evaluation of Configuration properties set in the project file before build time by giving back a global Configuration property to inject while building.
 /// </summary>
-internal class ReleasePropertyProjectLocator
+internal sealed class ReleasePropertyProjectLocator(
+    ReadOnlyDictionary<string, string>? userSpecifiedExplicitMSBuildProperties,
+    string propertyToCheck,
+    ReleasePropertyProjectLocator.DependentCommandOptions commandOptions)
 {
-    public struct DependentCommandOptions
+    public readonly struct DependentCommandOptions(IEnumerable<string>? slnOrProjectArgs, string? configOption = null, string? frameworkOption = null)
     {
-        public IEnumerable<string> SlnOrProjectArgs = [];
-        public string? FrameworkOption;
-        public string? ConfigurationOption;
-
-        public DependentCommandOptions(IEnumerable<string>? slnOrProjectArgs, string? configOption = null, string? frameworkOption = null)
-        => (SlnOrProjectArgs, ConfigurationOption, FrameworkOption) = (slnOrProjectArgs ?? [], configOption, frameworkOption);
+        public readonly IEnumerable<string> SlnOrProjectArgs = slnOrProjectArgs ?? [];
+        public readonly string? FrameworkOption = frameworkOption;
+        public readonly string? ConfigurationOption = configOption;
     }
 
-    private readonly ParseResult _parseResult;
-    private readonly string _propertyToCheck;
-    DependentCommandOptions _options;
-
-    private readonly IEnumerable<string> _slnOrProjectArgs;
+    private const string SolutionFolderGuid = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}";
+    private const string SharedProjectGuid = "{D954291E-2A0B-460D-934E-DC6B0785DB48}";
+    
     private bool _isHandlingSolution = false;
 
-    private static readonly string solutionFolderGuid = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}";
-    private static readonly string sharedProjectGuid = "{D954291E-2A0B-460D-934E-DC6B0785DB48}";
-
-    // <summary>
-    /// <param name="propertyToCheck">The boolean property to check the project for. Ex: PublishRelease, PackRelease.</param>
-    /// </summary>
-    public ReleasePropertyProjectLocator(
-        ParseResult parseResult,
-        string propertyToCheck,
-        DependentCommandOptions commandOptions
-     )
-     => (_parseResult, _propertyToCheck, _options, _slnOrProjectArgs) = (parseResult, propertyToCheck, commandOptions, commandOptions.SlnOrProjectArgs);
-
     /// <summary>
     /// Return dotnet CLI command-line parameters (or an empty list) to change configuration based on ...
     /// ... a boolean that may or may not exist in the targeted project.
@@ -60,19 +45,19 @@ DependentCommandOptions commandOptions
     public ReadOnlyDictionary<string, string>? GetCustomDefaultConfigurationValueIfSpecified()
     {
         // Setup
-        Debug.Assert(_propertyToCheck == MSBuildPropertyNames.PUBLISH_RELEASE || _propertyToCheck == MSBuildPropertyNames.PACK_RELEASE, "Only PackRelease or PublishRelease are currently expected.");
+        Debug.Assert(propertyToCheck == MSBuildPropertyNames.PUBLISH_RELEASE || propertyToCheck == MSBuildPropertyNames.PACK_RELEASE, "Only PackRelease or PublishRelease are currently expected.");
         if (string.Equals(Environment.GetEnvironmentVariable(EnvironmentVariableNames.DISABLE_PUBLISH_AND_PACK_RELEASE), "true", StringComparison.OrdinalIgnoreCase))
         {
             return null;
         }
 
         // Analyze Global Properties
-        var globalProperties = GetUserSpecifiedExplicitMSBuildProperties();
+        var globalProperties = userSpecifiedExplicitMSBuildProperties;
         globalProperties = InjectTargetFrameworkIntoGlobalProperties(globalProperties);
 
         // Configuration doesn't work in a .proj file, but it does as a global property.
         // Detect either A) --configuration option usage OR /p:Configuration=Foo, if so, don't use these properties.
-        if (_options.ConfigurationOption != null || globalProperties is not null && globalProperties.ContainsKey(MSBuildPropertyNames.CONFIGURATION))
+        if (commandOptions.ConfigurationOption != null || globalProperties is not null && globalProperties.ContainsKey(MSBuildPropertyNames.CONFIGURATION))
             return new Dictionary<string, string>(1, StringComparer.OrdinalIgnoreCase) { [EnvironmentVariableNames.DISABLE_PUBLISH_AND_PACK_RELEASE] = "true" }.AsReadOnly(); // Don't throw error if publish* conflicts but global config specified.
 
         // Determine the project being acted upon
@@ -81,7 +66,7 @@ DependentCommandOptions commandOptions
         // Determine the correct value to return
         if (project != null)
         {
-            string propertyToCheckValue = project.GetPropertyValue(_propertyToCheck);
+            string propertyToCheckValue = project.GetPropertyValue(propertyToCheck);
             if (!string.IsNullOrEmpty(propertyToCheckValue))
             {
                 var newConfigurationArgs = new Dictionary<string, string>(2, StringComparer.OrdinalIgnoreCase);
@@ -93,7 +78,7 @@ DependentCommandOptions commandOptions
 
                 if (_isHandlingSolution) // This will allow us to detect conflicting configuration values during evaluation.
                 {
-                    newConfigurationArgs[$"_SolutionLevel{_propertyToCheck}"] = propertyToCheckValue;
+                    newConfigurationArgs[$"_SolutionLevel{propertyToCheck}"] = propertyToCheckValue;
                 }
 
                 return newConfigurationArgs.AsReadOnly();
@@ -109,7 +94,7 @@ DependentCommandOptions commandOptions
     /// Will return an arbitrary project in the solution if one exists in the solution and there's no project targeted.</returns>
     public ProjectInstance? GetTargetedProject(ReadOnlyDictionary<string, string>? globalProps)
     {
-        foreach (string arg in _slnOrProjectArgs.Append(Directory.GetCurrentDirectory()))
+        foreach (string arg in commandOptions.SlnOrProjectArgs.Append(Directory.GetCurrentDirectory()))
         {
             if (VirtualProjectBuilder.IsValidEntryPointPath(arg))
             {
@@ -188,7 +173,7 @@ DependentCommandOptions commandOptions
                 return;
             }
 
-            string pReleasePropertyValue = projectData.GetPropertyValue(_propertyToCheck);
+            string pReleasePropertyValue = projectData.GetPropertyValue(propertyToCheck);
             if (!string.IsNullOrEmpty(pReleasePropertyValue))
             {
                 lock (projectDataLock)
@@ -205,7 +190,7 @@ DependentCommandOptions commandOptions
             // 1) This error should not be thrown in VS because it is part of the SDK CLI code
             // 2) If PublishRelease or PackRelease is disabled via opt out, or Configuration is specified, we won't get to this code, so we won't error
             // 3) This code only gets hit if we are in a solution publish setting, so we don't need to worry about it failing other publish scenarios
-            throw new GracefulException(Strings.SolutionProjectConfigurationsConflict, _propertyToCheck, string.Join("\n", (configuredProjects).Select(x => x.FullPath)));
+            throw new GracefulException(Strings.SolutionProjectConfigurationsConflict, propertyToCheck, string.Join("\n", (configuredProjects).Select(x => x.FullPath)));
         }
         return configuredProjects.FirstOrDefault();
     }
@@ -244,7 +229,7 @@ DependentCommandOptions commandOptions
     /// <returns>True if the project is not supported by ProjectInstance class or appears to be invalid.</returns>
     private bool IsUnanalyzableProjectInSolution(SolutionProjectModel project, string projectFullPath)
     {
-        return project.TypeId.ToString() == solutionFolderGuid || project.TypeId.ToString() == sharedProjectGuid || !IsValidProjectFilePath(projectFullPath);
+        return project.TypeId.ToString() == SolutionFolderGuid || project.TypeId.ToString() == SharedProjectGuid || !IsValidProjectFilePath(projectFullPath);
     }
 
     /// <returns>Creates a ProjectInstance if the project is valid, elsewise, fails.</returns>
@@ -273,9 +258,6 @@ private static bool IsValidSlnFilePath(string path)
         return File.Exists(path) && (Path.GetExtension(path).Equals(".sln") || Path.GetExtension(path).Equals(".slnx"));
     }
 
-    /// <returns>A case-insensitive dictionary of any properties passed from the user and their values.</returns>
-    private ReadOnlyDictionary<string, string>? GetUserSpecifiedExplicitMSBuildProperties() => _parseResult.GetValue(CommonOptions.PropertiesOption);
-
     /// <summary>
     /// Because command-line options that translate to MSBuild properties aren't in the global arguments from Properties, we need to add the TargetFramework to the collection.
     /// The TargetFramework is the only command-line option besides Configuration that could affect the pre-evaluation.
@@ -287,13 +269,13 @@ private static bool IsValidSlnFilePath(string path)
     {
         if (globalProperties is null || globalProperties.Count == 0)
         {
-            if (_options.FrameworkOption != null)
+            if (commandOptions.FrameworkOption != null)
             {
-                return new(new Dictionary<string, string>() { [MSBuildPropertyNames.TARGET_FRAMEWORK] = _options.FrameworkOption });
+                return new(new Dictionary<string, string>() { [MSBuildPropertyNames.TARGET_FRAMEWORK] = commandOptions.FrameworkOption });
             }
             return null;
         }
-        if (_options.FrameworkOption is null)
+        if (commandOptions.FrameworkOption is null)
         {
             return globalProperties;
         }
@@ -301,7 +283,7 @@ private static bool IsValidSlnFilePath(string path)
         var newDictionary = new Dictionary<string, string>(globalProperties, StringComparer.OrdinalIgnoreCase);
         // Note: dotnet -f FRAMEWORK_1 --property:TargetFramework=FRAMEWORK_2 will use FRAMEWORK_1.
         // So we can replace the value in the globals non-dubiously if it exists.
-        newDictionary[MSBuildPropertyNames.TARGET_FRAMEWORK] = _options.FrameworkOption;
+        newDictionary[MSBuildPropertyNames.TARGET_FRAMEWORK] = commandOptions.FrameworkOption;
         return new(newDictionary);
     }
 }
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
index 19a31f9c663b..d8a6b6ff951b 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
@@ -444,7 +444,7 @@ public void RunningWithGlobalPropertyShouldProperlyPropagate(string configuratio
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
                                         "-c", configuration,
-                                        CommonOptions.PropertiesOption.Name, "PROPERTY_TO_ENABLE_MTP=1");
+                                        "--property", "PROPERTY_TO_ENABLE_MTP=1");
 
             if (!TestContext.IsLocalized())
             {
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs
index 90e3f6edd781..08ae170e6db3 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTestsForMultipleTFMs.cs
@@ -115,7 +115,7 @@ public void RunProjectWithMultipleTFMs_ParallelizationTest_RunInParallelShouldFa
 
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
-                                    .Execute(CommonOptions.PropertiesOption.Name, $"TestTfmsInParallel={testTfmsInParallel}");
+                                    .Execute("--property", $"TestTfmsInParallel={testTfmsInParallel}");
 
             if (testTfmsInParallel)
             {

From e8dea68aa9a64c79439be829f424476af4b06fa6 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 14:36:21 -0800
Subject: [PATCH 17/20] Remaining options

---
 .../ProjectToolsCommandResolver.cs            |  4 +--
 src/Cli/dotnet/Commands/Build/BuildCommand.cs |  4 +--
 .../Commands/Build/BuildCommandDefinition.cs  |  4 +--
 src/Cli/dotnet/Commands/Clean/CleanCommand.cs |  4 +--
 .../dotnet/Commands/MSBuild/MSBuildCommand.cs |  4 +--
 .../Commands/MSBuild/MSBuildForwardingApp.cs  |  2 +-
 src/Cli/dotnet/Commands/Pack/PackCommand.cs   |  6 ++--
 .../dotnet/Commands/Publish/PublishCommand.cs |  8 ++---
 .../Publish/PublishCommandDefinition.cs       |  5 ++--
 .../Restore/ImplicitRestoreOptions.cs         |  4 +--
 .../dotnet/Commands/Restore/RestoreCommand.cs |  4 +--
 .../dotnet/Commands/Run/Api/RunApiCommand.cs  |  3 +-
 src/Cli/dotnet/Commands/Run/RunCommand.cs     | 13 +++------
 .../Commands/Run/RunCommandDefinition.cs      |  8 ++---
 .../Commands/Test/MTP/MSBuildUtility.cs       |  8 ++---
 ...mandDefinition.MicrosoftTestingPlatform.cs |  4 +--
 .../Test/TestCommandDefinition.VSTest.cs      |  6 ++--
 .../Commands/Test/VSTest/TestCommand.cs       |  6 ++--
 src/Cli/dotnet/CommonOptions.cs               | 16 ++++------
 .../MSBuild/GivenDotnetRunInvocation.cs       |  4 +--
 .../MSBuildArgumentCommandLineParserTests.cs  |  5 ++--
 .../CommandTests/Run/RunCommandTests.cs       |  3 +-
 .../Test/GivenDotnetTestBuildsAndRunsTests.cs |  2 +-
 .../Test/TestCommandParserTests.cs            |  4 +--
 .../ParserTests/CommonOptionsTests.cs         | 29 ++++++++++++-------
 25 files changed, 78 insertions(+), 82 deletions(-)

diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
index 6c0b4ba50a4e..a36d6a8b9351 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
@@ -387,8 +387,8 @@ internal void GenerateDepsJsonFile(
 
         var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
             [.. args],
-            CommonOptions.PropertiesOption,
-            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
             CommonOptions.CreateMSBuildTargetOption(),
             CommonOptions.CreateVerbosityOption(),
             CommonOptions.CreateNoLogoOption());
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommand.cs b/src/Cli/dotnet/Commands/Build/BuildCommand.cs
index 82bc09304815..c97289de5f88 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommand.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommand.cs
@@ -46,8 +46,8 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
             ),
             optionsToUseWhenParsingMSBuildFlags:
             [
-                CommonOptions.PropertiesOption,
-                CommonOptions.RestorePropertiesOption,
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
                 CommonOptions.CreateMSBuildTargetOption(),
                 CommonOptions.CreateVerbosityOption(),
                 CommonOptions.CreateNoLogoOption()
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
index b870c9bc075c..65bb225e8de4 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -42,9 +42,9 @@ internal sealed class BuildCommandDefinition : Command
 
     public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
-    public readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.CreateSelfContainedOption();
 
-    public readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.CreateNoSelfContainedOption();
 
     public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.BuildRuntimeOptionDescription);
 
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
index 60db55970d29..ee22ae1d3900 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
@@ -37,8 +37,8 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
             createPhysicalCommand: static (msbuildArgs, msbuildPath) => new CleanCommand(msbuildArgs, msbuildPath),
             optionsToUseWhenParsingMSBuildFlags:
             [
-                CommonOptions.PropertiesOption,
-                CommonOptions.RestorePropertiesOption,
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
                 CleanCommandDefinition.CreateTargetOption(),
                 CommonOptions.CreateVerbosityOption(VerbosityOptions.normal),
                 CommonOptions.CreateNoLogoOption()
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
index 4a697d9ddf25..3523f44f4342 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
@@ -13,8 +13,8 @@ public class MSBuildCommand(
     string? msbuildPath = null
 ) : MSBuildForwardingApp(MSBuildArgs.AnalyzeMSBuildArguments(
         [.. msbuildArgs],
-        CommonOptions.PropertiesOption,
-        CommonOptions.RestorePropertiesOption,
+        CommonOptions.CreatePropertyOption(),
+        CommonOptions.CreateRestorePropertyOption(),
         MSBuildCommandDefinition.TargetOption,
         CommonOptions.CreateVerbosityOption(),
         // We set the no-logo option to false here to ensure that by default the logo is shown for this command.
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
index 719a19d57189..752654bdf3f0 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
@@ -42,7 +42,7 @@ private static MSBuildArgs ConcatTelemetryLogger(MSBuildArgs msbuildArgs)
     /// Mostly intended for quick/one-shot usage - most 'core' SDK commands should do more hands-on parsing.
     /// </summary>
     public MSBuildForwardingApp(IEnumerable<string> rawMSBuildArgs, string? msbuildPath = null) : this(
-        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption()),
+        MSBuildArgs.AnalyzeMSBuildArguments(rawMSBuildArgs.ToArray(), CommonOptions.CreatePropertyOption(), CommonOptions.CreateRestorePropertyOption(), CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption()),
         msbuildPath)
     {
     }
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommand.cs b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
index 2f38f51d72ff..bba916eb775f 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommand.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
@@ -57,8 +57,8 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 msbuildPath),
             optionsToUseWhenParsingMSBuildFlags:
             [
-                CommonOptions.PropertiesOption,
-                CommonOptions.RestorePropertiesOption,
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
                 PackCommandDefinition.CreateTargetOption(),
                 CommonOptions.CreateVerbosityOption(),
                 CommonOptions.CreateNoLogoOption()
@@ -67,7 +67,7 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
             msbuildPath,
             transformer: (msbuildArgs) =>
             {
-                ReleasePropertyProjectLocator projectLocator = new(parseResult.GetValue(CommonOptions.PropertiesOption), MSBuildPropertyNames.PACK_RELEASE,
+                ReleasePropertyProjectLocator projectLocator = new(msbuildArgs.GlobalProperties, MSBuildPropertyNames.PACK_RELEASE,
                     new ReleasePropertyProjectLocator.DependentCommandOptions(
                             nonBinLogArgs,
                             parseResult.HasOption(definition.ConfigurationOption) ? parseResult.GetValue(definition.ConfigurationOption) : null
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
index abf792bee5bd..db75885e6da0 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
@@ -62,22 +62,22 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
             ),
             optionsToUseWhenParsingMSBuildFlags:
             [
-                CommonOptions.PropertiesOption,
-                CommonOptions.RestorePropertiesOption,
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
                 PublishCommandDefinition.CreateTargetOption(),
                 CommonOptions.CreateVerbosityOption(),
                 CommonOptions.CreateNoLogoOption()
             ],
             parseResult,
             msbuildPath,
-            (msbuildArgs) =>
+            transformer: (msbuildArgs) =>
             {
                 var options = new ReleasePropertyProjectLocator.DependentCommandOptions(
                         nonBinLogArgs,
                         parseResult.HasOption(definition.ConfigurationOption) ? parseResult.GetValue(definition.ConfigurationOption) : null,
                         parseResult.HasOption(definition.FrameworkOption) ? parseResult.GetValue(definition.FrameworkOption) : null
                     );
-                var projectLocator = new ReleasePropertyProjectLocator(parseResult.GetValue(CommonOptions.PropertiesOption), MSBuildPropertyNames.PUBLISH_RELEASE, options);
+                var projectLocator = new ReleasePropertyProjectLocator(msbuildArgs.GlobalProperties, MSBuildPropertyNames.PUBLISH_RELEASE, options);
                 var releaseModeProperties = projectLocator.GetCustomDefaultConfigurationValueIfSpecified();
                 return msbuildArgs.CloneWithAdditionalProperties(releaseModeProperties);
             }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
index 23f60b4e59e5..7fcf76edb936 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -3,7 +3,6 @@
 
 using System.CommandLine;
 using Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Build;
 using Microsoft.DotNet.Cli.Commands.Restore;
 using Microsoft.DotNet.Cli.Extensions;
 
@@ -44,9 +43,9 @@ internal sealed class PublishCommandDefinition : Command
 
     public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
-    public readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.CreateSelfContainedOption();
 
-    public readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.CreateNoSelfContainedOption();
 
     public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.PublishRuntimeOptionDescription);
 
diff --git a/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
index 70c000115848..379f2a6db850 100644
--- a/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
+++ b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
@@ -80,8 +80,8 @@ public ImplicitRestoreOptions(bool showHelp, bool useShortOptions)
             ForceOption.Aliases.Add("-f");
         }
 
-        PropertiesOption = CommonOptions.PropertiesOption;
-        RestorePropertiesOption = CommonOptions.RestorePropertiesOption;
+        PropertiesOption = CommonOptions.CreatePropertyOption();
+        RestorePropertiesOption = CommonOptions.CreateRestorePropertyOption();
     }
 
     private static Option<IEnumerable<string>> CreateSourceOption(bool showHelp, bool useShortOptions)
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
index 902b40ec60f3..a79d38066986 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
@@ -44,8 +44,8 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
             },
             optionsToUseWhenParsingMSBuildFlags:
             [
-                CommonOptions.PropertiesOption,
-                CommonOptions.RestorePropertiesOption,
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
                 RestoreCommandDefinition.CreateTargetOption(),
                 CommonOptions.CreateVerbosityOption(),
                 CommonOptions.CreateNoLogoOption()
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
index 1a3cb3645bfa..8217e1744580 100644
--- a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
@@ -112,8 +112,7 @@ public override RunApiOutput Execute()
                 msbuildArgs: msbuildArgs,
                 applicationArgs: [],
                 readCodeFromStdin: false,
-                environmentVariables: ReadOnlyDictionary<string, string>.Empty,
-                msbuildRestoreProperties: ReadOnlyDictionary<string, string>.Empty);
+                environmentVariables: ReadOnlyDictionary<string, string>.Empty);
 
             var result = runCommand.ReadLaunchProfileSettings();
             var targetCommand = (Utils.Command)runCommand.GetTargetCommand(result.Profile, buildCommand.CreateProjectInstance, cachedRunProperties: null);
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index 588f9a5eeb4b..40a21c7f1f7e 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -49,8 +49,6 @@ public class RunCommand
     /// </summary>
     public bool ReadCodeFromStdin { get; }
 
-    public ReadOnlyDictionary<string, string>? RestoreProperties { get; }
-
     /// <summary>
     /// unparsed/arbitrary CLI tokens to be passed to the running application
     /// </summary>
@@ -102,8 +100,7 @@ public RunCommand(
         MSBuildArgs msbuildArgs,
         string[] applicationArgs,
         bool readCodeFromStdin,
-        IReadOnlyDictionary<string, string> environmentVariables,
-        ReadOnlyDictionary<string, string>? msbuildRestoreProperties)
+        IReadOnlyDictionary<string, string> environmentVariables)
     {
         Debug.Assert(projectFileFullPath is null ^ entryPointFileFullPath is null);
         Debug.Assert(!readCodeFromStdin || entryPointFileFullPath is not null);
@@ -121,7 +118,6 @@ public RunCommand(
         NoCache = noCache;
         MSBuildArgs = SetupSilentBuildArgs(msbuildArgs);
         EnvironmentVariables = environmentVariables;
-        RestoreProperties = msbuildRestoreProperties;
     }
 
     public int Execute()
@@ -767,8 +763,8 @@ public static RunCommand FromParseResult(ParseResult parseResult)
 
         var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
             msbuildProperties,
-            CommonOptions.PropertiesOption,
-            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
             CommonOptions.CreateMSBuildTargetOption(),
             definition.VerbosityOption);
 
@@ -785,8 +781,7 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             msbuildArgs: msbuildArgs,
             applicationArgs: args,
             readCodeFromStdin: readCodeFromStdin,
-            environmentVariables: parseResult.GetValue(CommonOptions.EnvOption) ?? ImmutableDictionary<string, string>.Empty,
-            msbuildRestoreProperties: parseResult.GetValue(CommonOptions.RestorePropertiesOption)
+            environmentVariables: parseResult.GetValue(definition.EnvOption) ?? ImmutableDictionary<string, string>.Empty
         );
 
         return command;
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
index 8ac053b536e3..8e5f9cdc3f16 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -29,7 +29,7 @@ internal sealed class RunCommandDefinition : Command
         HelpName = CliCommandStrings.CommandOptionFileHelpName,
     };
 
-    public readonly Option<ReadOnlyDictionary<string, string>?> PropertyOption = CommonOptions.PropertiesOption;
+    public readonly Option<ReadOnlyDictionary<string, string>?> PropertyOption = CommonOptions.CreatePropertyOption();
 
     public readonly Option<string> LaunchProfileOption = new("--launch-profile", "-lp")
     {
@@ -68,9 +68,9 @@ internal sealed class RunCommandDefinition : Command
         Arity = ArgumentArity.Zero,
     };
 
-    public readonly Option SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.CreateSelfContainedOption();
 
-    public readonly Option NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.CreateNoSelfContainedOption();
 
     public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
@@ -78,7 +78,7 @@ internal sealed class RunCommandDefinition : Command
 
     public readonly Option<string> ArtifactsPathOption = CommonOptions.CreateArtifactsPathOption();
 
-    public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
+    public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.CreateEnvOption();
 
     public readonly Argument<string[]> ApplicationArguments = new("applicationArguments")
     {
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
index 5ec2bc7930b4..d3363ec03346 100644
--- a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
+++ b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
@@ -35,7 +35,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
             return (Array.Empty<ParallelizableTestModuleGroupWithSequentialInnerModules>(), isBuiltOrRestored);
         }
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption());
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.CreatePropertyOption(), CommonOptions.CreateRestorePropertyOption(), CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption());
         var solutionFile = SolutionFile.Parse(Path.GetFullPath(solutionFilePath));
         var globalProperties = CommonRunHelpers.GetGlobalPropertiesFromArgs(msbuildArgs);
 
@@ -87,7 +87,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
 
         FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. buildOptions.MSBuildArgs], dotnetTestVerb);
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption());
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(buildOptions.MSBuildArgs, CommonOptions.CreatePropertyOption(), CommonOptions.CreateRestorePropertyOption(), CommonOptions.CreateMSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.CreateNoLogoOption());
 
         using var collection = new ProjectCollection(globalProperties: CommonRunHelpers.GetGlobalPropertiesFromArgs(msbuildArgs), logger is null ? null : [logger], toolsetDefinitionLocations: ToolsetDefinitionLocations.Default);
         var evaluationContext = EvaluationContext.Create(EvaluationContext.SharingPolicy.Shared);
@@ -157,8 +157,8 @@ private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOption
 
         var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
             msbuildArgs,
-            CommonOptions.PropertiesOption,
-            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
             CommonOptions.CreateRequiredMSBuildTargetOption(CliConstants.MTPTarget),
             CommonOptions.CreateVerbosityOption(),
             CommonOptions.CreateNoLogoOption());
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
index 90051e54ab20..f7a6931a7664 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
@@ -77,9 +77,9 @@ public sealed class MicrosoftTestingPlatform : TestCommandDefinition, ICustomHel
             HelpName = CliCommandStrings.CmdNumberName
         };
 
-        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.EnvOption;
+        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.CreateEnvOption();
 
-        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.CreatePropertyOption();
 
         public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
index aba5e25f6bab..2f8ae4c3b5a2 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
@@ -24,7 +24,7 @@ public sealed class VSTest : TestCommandDefinition
             Arity = ArgumentArity.Zero
         }.ForwardAs("-property:VSTestListTests=true");
 
-        public readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.TestEnvOption;
+        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.CreateEnvOption(CliStrings.CmdTestEnvironmentVariableDescription);
 
         public readonly Option<string> FilterOption = new Option<string>("--filter")
         {
@@ -125,7 +125,7 @@ public sealed class VSTest : TestCommandDefinition
 
         public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
-        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.PropertiesOption;
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.CreatePropertyOption();
 
         public readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
 
@@ -163,7 +163,7 @@ public VSTest()
 
             Options.Add(SettingsOption);
             Options.Add(ListTestsOption);
-            Options.Add(TestEnvOption);
+            Options.Add(EnvOption);
             Options.Add(FilterOption);
             Options.Add(AdapterOption);
             Options.Add(LoggerOption);
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
index 62a011caa3a9..951fec104150 100644
--- a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
+++ b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
@@ -239,8 +239,8 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
 
         var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
             msbuildArgs,
-            CommonOptions.PropertiesOption,
-            CommonOptions.RestorePropertiesOption,
+            CommonOptions.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
             CommonOptions.CreateRequiredMSBuildTargetOption("VSTest"),
             CommonOptions.CreateVerbosityOption(),
             CommonOptions.CreateNoLogoOption())
@@ -252,7 +252,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             msbuildPath);
 
         // Apply environment variables provided by the user via --environment (-e) option, if present
-        if (result.GetValue(definition.TestEnvOption) is { } environmentVariables)
+        if (result.GetValue(definition.EnvOption) is { } environmentVariables)
         {
             foreach (var (name, value) in environmentVariables)
             {
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 18c9296b91de..cfb1f2e994df 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -20,7 +20,7 @@ internal static class CommonOptions
         IsDynamic = true
     };
 
-    public static Option<ReadOnlyDictionary<string, string>?> PropertiesOption =
+    public static Option<ReadOnlyDictionary<string, string>?> CreatePropertyOption() =>
         // these are all of the forms that the property switch can be understood by in MSBuild
         new Option<ReadOnlyDictionary<string, string>?>("--property", "-property", "/property", "/p", "-p", "--p")
         {
@@ -35,7 +35,7 @@ internal static class CommonOptions
     /// </summary>
     /// <remarks>
     /// </remarks>
-    public static Option<ReadOnlyDictionary<string, string>?> RestorePropertiesOption =
+    public static Option<ReadOnlyDictionary<string, string>?> CreateRestorePropertyOption() =>
         // these are all of the forms that the property switch can be understood by in MSBuild
         new Option<ReadOnlyDictionary<string, string>?>("--restoreProperty", "-restoreProperty", "/restoreProperty", "-rp", "--rp", "/rp")
         {
@@ -277,14 +277,14 @@ public static Option<bool> CreateDisableBuildServersOption() =>
         Arity = ArgumentArity.Zero,
     };
 
-    public static Option<bool> SelfContainedOption =
+    public static Option<bool> CreateSelfContainedOption() =>
         new Option<bool>("--self-contained", "--sc")
         {
             Description = CliStrings.SelfContainedOptionDescription
         }
         .ForwardIfEnabled([$"--property:SelfContained=true", "--property:_CommandLineDefinedSelfContained=true"]);
 
-    public static Option<bool> NoSelfContainedOption =
+    public static Option<bool> CreateNoSelfContainedOption() =>
         new Option<bool>("--no-self-contained")
         {
             Description = CliStrings.FrameworkDependentOptionDescription,
@@ -292,19 +292,15 @@ public static Option<bool> CreateDisableBuildServersOption() =>
         }
         .ForwardIfEnabled([$"--property:SelfContained=false", "--property:_CommandLineDefinedSelfContained=true"]);
 
-    public static Option<IReadOnlyDictionary<string, string>> CreateEnvOption(string description) => new("--environment", "-e")
+    public static Option<IReadOnlyDictionary<string, string>> CreateEnvOption(string? description = null) => new("--environment", "-e")
     {
-        Description = description,
+        Description = description ?? CliStrings.CmdEnvironmentVariableDescription,
         HelpName = CliStrings.CmdEnvironmentVariableExpression,
         CustomParser = ParseEnvironmentVariables,
         // Can't allow multiple arguments because the separator needs to be parsed as part of the environment variable value.
         AllowMultipleArgumentsPerToken = false
     };
 
-    public static readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CreateEnvOption(CliStrings.CmdEnvironmentVariableDescription);
-    
-    public static readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CreateEnvOption(CliStrings.CmdTestEnvironmentVariableDescription);
-
     private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(ArgumentResult argumentResult)
     {
         var result = new Dictionary<string, string>(
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
index 73e20560298d..6f646dda91fc 100644
--- a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
+++ b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
@@ -51,8 +51,8 @@ public void MsbuildInvocationIsCorrect(string[] args, string[] expectedArgs)
                         ],
                         options:
                         [
-                            CommonOptions.PropertiesOption,
-                            CommonOptions.RestorePropertiesOption,
+                            CommonOptions.CreatePropertyOption(),
+                            CommonOptions.CreateRestorePropertyOption(),
                             CommonOptions.CreateMSBuildTargetOption(),
                             CommonOptions.CreateVerbosityOption(),
                             CommonOptions.CreateNoLogoOption()
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/MSBuildArgumentCommandLineParserTests.cs b/test/dotnet.Tests/CommandTests/MSBuild/MSBuildArgumentCommandLineParserTests.cs
index f84a1847007d..6c25a9ee613c 100644
--- a/test/dotnet.Tests/CommandTests/MSBuild/MSBuildArgumentCommandLineParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/MSBuild/MSBuildArgumentCommandLineParserTests.cs
@@ -53,8 +53,9 @@ public void MSBuildArgumentsAreForwardedCorrectly(string[] arguments, bool build
         [InlineData(new string[] { "-p:RuntimeIdentifiers=linux-x64;linux-arm64" }, new string[] { "--property:RuntimeIdentifiers=linux-x64;linux-arm64" })]
         public void Can_pass_msbuild_properties_safely(string[] tokens, string[] forwardedTokens)
         {
-            var forwardingFunction = CommonOptions.PropertiesOption.ForwardingFunction!;
-            var result = new RootCommand() { CommonOptions.PropertiesOption }.Parse(tokens);
+            var option = CommonOptions.CreatePropertyOption();
+            var forwardingFunction = option.ForwardingFunction!;
+            var result = new RootCommand() { option }.Parse(tokens);
             var parsedTokens = forwardingFunction(result);
             parsedTokens.Should().BeEquivalentTo(forwardedTokens);
         }
diff --git a/test/dotnet.Tests/CommandTests/Run/RunCommandTests.cs b/test/dotnet.Tests/CommandTests/Run/RunCommandTests.cs
index 1bfa504ba4f6..5504bd51c710 100644
--- a/test/dotnet.Tests/CommandTests/Run/RunCommandTests.cs
+++ b/test/dotnet.Tests/CommandTests/Run/RunCommandTests.cs
@@ -30,8 +30,7 @@ private static RunCommand CreateRunCommand(
             MSBuildArgs.FromOtherArgs([]),
             applicationArgs: applicationArgs ?? [],
             readCodeFromStdin: false,
-            environmentVariables: new Dictionary<string, string>(),
-            msbuildRestoreProperties: new(new Dictionary<string, string>()));
+            environmentVariables: new Dictionary<string, string>());
 
     [Fact]
     public void EnvironmentVariableExpansion_Project()
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
index d8a6b6ff951b..033d929a9e1f 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsTests.cs
@@ -571,7 +571,7 @@ public void RunTestProjectWithEnvVariable(string configuration)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
                                         "-c", configuration,
-                                        CommonOptions.EnvOption.Name, "DUMMY_TEST_ENV_VAR=ENV_VAR_CMD_LINE");
+                                        "--environment", "DUMMY_TEST_ENV_VAR=ENV_VAR_CMD_LINE");
 
             if (!TestContext.IsLocalized())
             {
diff --git a/test/dotnet.Tests/CommandTests/Test/TestCommandParserTests.cs b/test/dotnet.Tests/CommandTests/Test/TestCommandParserTests.cs
index f566d659d2c6..07b270b43e92 100644
--- a/test/dotnet.Tests/CommandTests/Test/TestCommandParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/Test/TestCommandParserTests.cs
@@ -70,8 +70,8 @@ public void VSTestCommandIncludesPropertiesOption()
             var propertyOption = command.Options.FirstOrDefault(o => 
                 o.Aliases.Contains("/p") || o.Aliases.Contains("--property"));
             
-            propertyOption.Should().NotBeNull("VSTest command should include CommonOptions.PropertiesOption to support /p Property=Value syntax");
-            propertyOption.Aliases.Should().Contain("/p", "PropertiesOption should include /p alias for MSBuild compatibility");
+            propertyOption.Should().NotBeNull("VSTest command should include CommonOptions.CreatePropertyOption to support /p Property=Value syntax");
+            propertyOption.Aliases.Should().Contain("/p", "CreatePropertyOption should include /p alias for MSBuild compatibility");
         }
 
         [Fact]
diff --git a/test/dotnet.Tests/ParserTests/CommonOptionsTests.cs b/test/dotnet.Tests/ParserTests/CommonOptionsTests.cs
index a7949775bade..7be63fab7433 100644
--- a/test/dotnet.Tests/ParserTests/CommonOptionsTests.cs
+++ b/test/dotnet.Tests/ParserTests/CommonOptionsTests.cs
@@ -12,11 +12,13 @@ public class CommonOptionsTests
     public void Duplicates()
     {
         var command = new RootCommand();
-        command.Options.Add(CommonOptions.EnvOption);
+        var option = CommonOptions.CreateEnvOption();
+
+        command.Options.Add(option);
 
         var result = command.Parse(["-e", "A=1", "-e", "A=2"]);
 
-        result.GetValue(CommonOptions.EnvOption)
+        result.GetValue(option)
             .Should()
             .BeEquivalentTo(new Dictionary<string, string> { ["A"] = "2" });
 
@@ -27,7 +29,8 @@ public void Duplicates()
     public void Duplicates_CasingDifference()
     {
         var command = new RootCommand();
-        command.Options.Add(CommonOptions.EnvOption);
+        var option = CommonOptions.CreateEnvOption();
+        command.Options.Add(option);
 
         var result = command.Parse(["-e", "A=1", "-e", "a=2"]);
 
@@ -43,7 +46,7 @@ public void Duplicates_CasingDifference()
             expected.Add("a", "2");
         }
 
-        result.GetValue(CommonOptions.EnvOption)
+        result.GetValue(option)
             .Should()
             .BeEquivalentTo(expected);
 
@@ -54,11 +57,12 @@ public void Duplicates_CasingDifference()
     public void MultiplePerToken()
     {
         var command = new RootCommand();
-        command.Options.Add(CommonOptions.EnvOption);
+        var option = CommonOptions.CreateEnvOption();
+        command.Options.Add(option);
 
         var result = command.Parse(["-e", "A=1;B=2,C=3 D=4", "-e", "B==Y=", "-e", "C;=;"]);
 
-        result.GetValue(CommonOptions.EnvOption)
+        result.GetValue(option)
             .Should()
             .BeEquivalentTo(new Dictionary<string, string>
             {
@@ -74,11 +78,12 @@ public void MultiplePerToken()
     public void NoValue()
     {
         var command = new RootCommand();
-        command.Options.Add(CommonOptions.EnvOption);
+        var option = CommonOptions.CreateEnvOption();
+        command.Options.Add(option);
 
         var result = command.Parse(["-e", "A"]);
 
-        result.GetValue(CommonOptions.EnvOption)
+        result.GetValue(option)
             .Should()
             .BeEquivalentTo(new Dictionary<string, string> { ["A"] = "" });
 
@@ -89,11 +94,12 @@ public void NoValue()
     public void WhitespaceTrimming()
     {
         var command = new RootCommand();
-        command.Options.Add(CommonOptions.EnvOption);
+        var option = CommonOptions.CreateEnvOption();
+        command.Options.Add(option);
 
         var result = command.Parse(["-e", " A \t\n\r\u2002 = X Y \t\n\r\u2002"]);
 
-        result.GetValue(CommonOptions.EnvOption)
+        result.GetValue(option)
             .Should()
             .BeEquivalentTo(new Dictionary<string, string> { ["A"] = " X Y \t\n\r\u2002" });
 
@@ -108,7 +114,8 @@ public void WhitespaceTrimming()
     public void Errors(string token)
     {
         var command = new RootCommand();
-        command.Options.Add(CommonOptions.EnvOption);
+        var option = CommonOptions.CreateEnvOption();
+        command.Options.Add(option);
 
         var result = command.Parse(["-e", token]);
 

From 3921f03aa0968a1bd8d1f09e73eadc9f415f91f5 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 15:58:21 -0800
Subject: [PATCH 18/20] Fixes

---
 .../dotnet-watch.Tests/CommandLine/CommandLineOptionsTests.cs | 2 +-
 .../MTPHelpSnapshotTests.VerifyMTPHelpOutput.verified.txt     | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/dotnet-watch.Tests/CommandLine/CommandLineOptionsTests.cs b/test/dotnet-watch.Tests/CommandLine/CommandLineOptionsTests.cs
index 2519f041901b..886e1e614d9a 100644
--- a/test/dotnet-watch.Tests/CommandLine/CommandLineOptionsTests.cs
+++ b/test/dotnet-watch.Tests/CommandLine/CommandLineOptionsTests.cs
@@ -435,7 +435,7 @@ public void ShortFormForLaunchProfileArgumentWorks()
         [Theory]
         [InlineData(new[] { "--configuration", "release" }, new[] { "--property:Configuration=release", NugetInteractiveProperty })]
         [InlineData(new[] { "--framework", "net9.0" }, new[] { "--property:TargetFramework=net9.0", NugetInteractiveProperty })]
-        [InlineData(new[] { "--runtime", "arm64" }, new[] { "--property:RuntimeIdentifier=arm64", "--property:_CommandLineDefinedRuntimeIdentifier=true", NugetInteractiveProperty })]
+        [InlineData(new[] { "--runtime", "arm64" }, new[] { NugetInteractiveProperty, "--property:RuntimeIdentifier=arm64", "--property:_CommandLineDefinedRuntimeIdentifier=true" })]
         [InlineData(new[] { "--property", "b=1" }, new[] { "--property:b=1", NugetInteractiveProperty })]
         [InlineData(new[] { "/p:b=1" }, new[] { "--property:b=1", NugetInteractiveProperty }, new[] { "/p", "b=1" })] // it's ok to split the argument into two since `dotnet run` handles `/p b=1`
         [InlineData(new[] { "--interactive" }, new[] { "--property:NuGetInteractive=true" })]
diff --git a/test/dotnet.Tests/CommandTests/Test/snapshots/MTPHelpSnapshotTests.VerifyMTPHelpOutput.verified.txt b/test/dotnet.Tests/CommandTests/Test/snapshots/MTPHelpSnapshotTests.VerifyMTPHelpOutput.verified.txt
index 333629304880..9e788f97f5c9 100644
--- a/test/dotnet.Tests/CommandTests/Test/snapshots/MTPHelpSnapshotTests.VerifyMTPHelpOutput.verified.txt
+++ b/test/dotnet.Tests/CommandTests/Test/snapshots/MTPHelpSnapshotTests.VerifyMTPHelpOutput.verified.txt
@@ -16,7 +16,6 @@ Options:
                                                   If not specified the file will be generated inside the default 'TestResults' directory.
   --max-parallel-test-modules <NUMBER>            The max number of test modules that can run in parallel.
   --minimum-expected-tests <NUMBER>               Specifies the minimum number of tests that are expected to run.
-  -a, --arch <ARCH>                               The target architecture.
   -e, --environment <NAME="VALUE">                Sets the value of an environment variable. 
                                                   Creates the variable if it does not exist, overrides if it does. 
                                                   This argument can be specified multiple times to provide multiple variables.
@@ -28,8 +27,9 @@ Options:
                                                   -e VAR1=abc -e VAR2=def -e VAR3=ghi
   -c, --configuration <CONFIGURATION>             The configuration to use for running tests. The default for most projects is 'Debug'.
   -f, --framework <FRAMEWORK>                     The target framework to run tests for. The target framework must also be specified in the project file.
-  --os <OS>                                       The target operating system.
   -r, --runtime <RUNTIME_IDENTIFIER>              The target runtime to test for.
+  -a, --arch <ARCH>                               The target architecture.
+  --os <OS>                                       The target operating system.
   -v, -verbosity <LEVEL>                          Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].
   --no-restore                                    Do not restore the project before building. [default: False]
   --no-build                                      Do not build the project before testing. Implies --no-restore. [default: False]

From 8cc95aa436e622048dacd9b0e5e5097fe96718db Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 16:02:07 -0800
Subject: [PATCH 19/20] Fix

---
 ...napshotTests.VerifyCompletions.verified.sh | 50 +++++++++----------
 ...apshotTests.VerifyCompletions.verified.ps1 | 20 ++++----
 ...apshotTests.VerifyCompletions.verified.zsh | 20 ++++----
 3 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/test/dotnet.Tests/CompletionTests/snapshots/bash/DotnetCliSnapshotTests.VerifyCompletions.verified.sh b/test/dotnet.Tests/CompletionTests/snapshots/bash/DotnetCliSnapshotTests.VerifyCompletions.verified.sh
index 5262ae7f1a47..2b8fed6a8b87 100644
--- a/test/dotnet.Tests/CompletionTests/snapshots/bash/DotnetCliSnapshotTests.VerifyCompletions.verified.sh
+++ b/test/dotnet.Tests/CompletionTests/snapshots/bash/DotnetCliSnapshotTests.VerifyCompletions.verified.sh
@@ -144,7 +144,7 @@ _testhost_build() {
     prev="${COMP_WORDS[COMP_CWORD-1]}" 
     COMPREPLY=()
     
-    opts="--use-current-runtime --framework --configuration --runtime --version-suffix --no-restore --interactive --verbosity --debug --output --artifacts-path --no-incremental --no-dependencies --no-logo --self-contained --no-self-contained --arch --os --disable-build-servers --help" 
+    opts="--use-current-runtime --framework --configuration --version-suffix --no-restore --interactive --verbosity --debug --output --artifacts-path --no-incremental --no-dependencies --no-logo --self-contained --no-self-contained --runtime --arch --os --disable-build-servers --help" 
     
     if [[ $COMP_CWORD == "$1" ]]; then
         COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -160,10 +160,6 @@ _testhost_build() {
             COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
             return
         ;;
-        --runtime|-r)
-            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
-            return
-        ;;
         --interactive)
             COMPREPLY=( $(compgen -W "False True" -- "$cur") )
             return
@@ -176,6 +172,10 @@ _testhost_build() {
             COMPREPLY=( $(compgen -W "False True" -- "$cur") )
             return
         ;;
+        --runtime|-r)
+            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
+            return
+        ;;
     esac
     
     COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1210,7 +1210,7 @@ _testhost_publish() {
     prev="${COMP_WORDS[COMP_CWORD-1]}" 
     COMPREPLY=()
     
-    opts="--use-current-runtime --output --artifacts-path --manifest --no-build --self-contained --no-self-contained --no-logo --framework --runtime --configuration --version-suffix --interactive --no-restore --verbosity --arch --os --disable-build-servers --help" 
+    opts="--use-current-runtime --output --artifacts-path --manifest --no-build --self-contained --no-self-contained --no-logo --framework --configuration --version-suffix --interactive --no-restore --verbosity --runtime --arch --os --disable-build-servers --help" 
     
     if [[ $COMP_CWORD == "$1" ]]; then
         COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1226,10 +1226,6 @@ _testhost_publish() {
             COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
             return
         ;;
-        --runtime|-r)
-            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
-            return
-        ;;
         --configuration|-c)
             COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
             return
@@ -1242,6 +1238,10 @@ _testhost_publish() {
             COMPREPLY=( $(compgen -W "d detailed diag diagnostic m minimal n normal q quiet" -- "$cur") )
             return
         ;;
+        --runtime|-r)
+            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
+            return
+        ;;
     esac
     
     COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1347,7 +1347,7 @@ _testhost_restore() {
     prev="${COMP_WORDS[COMP_CWORD-1]}" 
     COMPREPLY=()
     
-    opts="--disable-build-servers --source --packages --use-current-runtime --disable-parallel --configfile --no-http-cache --ignore-failed-sources --force --runtime --no-dependencies --verbosity --interactive --artifacts-path --use-lock-file --locked-mode --lock-file-path --force-evaluate --no-logo --arch --os --help" 
+    opts="--disable-build-servers --source --packages --use-current-runtime --disable-parallel --configfile --no-http-cache --ignore-failed-sources --force --no-dependencies --verbosity --interactive --artifacts-path --use-lock-file --locked-mode --lock-file-path --force-evaluate --no-logo --runtime --arch --os --help" 
     
     if [[ $COMP_CWORD == "$1" ]]; then
         COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1355,10 +1355,6 @@ _testhost_restore() {
     fi
     
     case $prev in
-        --runtime|-r)
-            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
-            return
-        ;;
         --verbosity|-v)
             COMPREPLY=( $(compgen -W "d detailed diag diagnostic m minimal n normal q quiet" -- "$cur") )
             return
@@ -1367,6 +1363,10 @@ _testhost_restore() {
             COMPREPLY=( $(compgen -W "False True" -- "$cur") )
             return
         ;;
+        --runtime|-r)
+            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
+            return
+        ;;
     esac
     
     COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1379,7 +1379,7 @@ _testhost_run() {
     prev="${COMP_WORDS[COMP_CWORD-1]}" 
     COMPREPLY=()
     
-    opts="--configuration --framework --runtime --project --file --launch-profile --no-launch-profile --no-build --interactive --no-restore --no-cache --self-contained --no-self-contained --verbosity --arch --os --disable-build-servers --artifacts-path --environment --help" 
+    opts="--configuration --framework --project --file --launch-profile --no-launch-profile --no-build --interactive --no-restore --no-cache --self-contained --no-self-contained --verbosity --runtime --arch --os --disable-build-servers --artifacts-path --environment --help" 
     
     if [[ $COMP_CWORD == "$1" ]]; then
         COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1395,10 +1395,6 @@ _testhost_run() {
             COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
             return
         ;;
-        --runtime|-r)
-            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
-            return
-        ;;
         --interactive)
             COMPREPLY=( $(compgen -W "False True" -- "$cur") )
             return
@@ -1411,6 +1407,10 @@ _testhost_run() {
             COMPREPLY=( $(compgen -W "d detailed diag diagnostic m minimal n normal q quiet" -- "$cur") )
             return
         ;;
+        --runtime|-r)
+            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
+            return
+        ;;
     esac
     
     COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1573,7 +1573,7 @@ _testhost_test() {
     prev="${COMP_WORDS[COMP_CWORD-1]}" 
     COMPREPLY=()
     
-    opts="--settings --list-tests --environment --filter --test-adapter-path --logger --output --artifacts-path --diag --no-build --results-directory --collect --blame --blame-crash --blame-crash-dump-type --blame-crash-collect-always --blame-hang --blame-hang-dump-type --blame-hang-timeout --no-logo --configuration --framework --runtime --no-restore --interactive --verbosity --arch --os --disable-build-servers --help" 
+    opts="--settings --list-tests --environment --filter --test-adapter-path --logger --output --artifacts-path --diag --no-build --results-directory --collect --blame --blame-crash --blame-crash-dump-type --blame-crash-collect-always --blame-hang --blame-hang-dump-type --blame-hang-timeout --no-logo --configuration --framework --no-restore --interactive --verbosity --runtime --arch --os --disable-build-servers --help" 
     
     if [[ $COMP_CWORD == "$1" ]]; then
         COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
@@ -1597,10 +1597,6 @@ _testhost_test() {
             COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
             return
         ;;
-        --runtime|-r)
-            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
-            return
-        ;;
         --interactive)
             COMPREPLY=( $(compgen -W "False True" -- "$cur") )
             return
@@ -1609,6 +1605,10 @@ _testhost_test() {
             COMPREPLY=( $(compgen -W "d detailed diag diagnostic m minimal n normal q quiet" -- "$cur") )
             return
         ;;
+        --runtime|-r)
+            COMPREPLY=( $(compgen -W "(${COMP_WORDS[0]} complete --position ${COMP_POINT} ${COMP_LINE} 2>/dev/null | tr '\n' ' ')" -- "$cur") )
+            return
+        ;;
     esac
     
     COMPREPLY=( $(compgen -W "$opts" -- "$cur") )
diff --git a/test/dotnet.Tests/CompletionTests/snapshots/pwsh/DotnetCliSnapshotTests.VerifyCompletions.verified.ps1 b/test/dotnet.Tests/CompletionTests/snapshots/pwsh/DotnetCliSnapshotTests.VerifyCompletions.verified.ps1
index 9f64c6e2086a..115266538ef2 100644
--- a/test/dotnet.Tests/CompletionTests/snapshots/pwsh/DotnetCliSnapshotTests.VerifyCompletions.verified.ps1
+++ b/test/dotnet.Tests/CompletionTests/snapshots/pwsh/DotnetCliSnapshotTests.VerifyCompletions.verified.ps1
@@ -67,8 +67,6 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--framework', '-f', [CompletionResultType]::ParameterName, "The target framework to build for. The target framework must also be specified in the project file.")
                 [CompletionResult]::new('--configuration', '--configuration', [CompletionResultType]::ParameterName, "The configuration to use for building the project. The default for most projects is `'Debug`'.")
                 [CompletionResult]::new('--configuration', '-c', [CompletionResultType]::ParameterName, "The configuration to use for building the project. The default for most projects is `'Debug`'.")
-                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to build for.")
-                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to build for.")
                 [CompletionResult]::new('--version-suffix', '--version-suffix', [CompletionResultType]::ParameterName, "Set the value of the `$(VersionSuffix) property to use when building the project.")
                 [CompletionResult]::new('--no-restore', '--no-restore', [CompletionResultType]::ParameterName, "Do not restore the project before building.")
                 [CompletionResult]::new('--interactive', '--interactive', [CompletionResultType]::ParameterName, "Allows the command to stop and wait for user input or action (for example to complete authentication).")
@@ -91,6 +89,8 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--self-contained', '--self-contained', [CompletionResultType]::ParameterName, "Publish the .NET runtime with your application so the runtime doesn`'t need to be installed on the target machine. The default is `'false.`' However, when targeting .NET 7 or lower, the default is `'true`' if a runtime identifier is specified.")
                 [CompletionResult]::new('--self-contained', '--sc', [CompletionResultType]::ParameterName, "Publish the .NET runtime with your application so the runtime doesn`'t need to be installed on the target machine. The default is `'false.`' However, when targeting .NET 7 or lower, the default is `'true`' if a runtime identifier is specified.")
                 [CompletionResult]::new('--no-self-contained', '--no-self-contained', [CompletionResultType]::ParameterName, "Publish your application as a framework dependent application. A compatible .NET runtime must be installed on the target machine to run your application.")
+                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to build for.")
+                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to build for.")
                 [CompletionResult]::new('--arch', '--arch', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--arch', '-a', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--os', '--os', [CompletionResultType]::ParameterName, "The target operating system.")
@@ -730,8 +730,6 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--no-logo', '/nologo', [CompletionResultType]::ParameterName, "Do not display the startup banner or the copyright message.")
                 [CompletionResult]::new('--framework', '--framework', [CompletionResultType]::ParameterName, "The target framework to publish for. The target framework has to be specified in the project file.")
                 [CompletionResult]::new('--framework', '-f', [CompletionResultType]::ParameterName, "The target framework to publish for. The target framework has to be specified in the project file.")
-                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.")
-                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.")
                 [CompletionResult]::new('--configuration', '--configuration', [CompletionResultType]::ParameterName, "The configuration to publish for. The default is `'Release`' for NET 8.0 projects and above, but `'Debug`' for older projects.")
                 [CompletionResult]::new('--configuration', '-c', [CompletionResultType]::ParameterName, "The configuration to publish for. The default is `'Release`' for NET 8.0 projects and above, but `'Debug`' for older projects.")
                 [CompletionResult]::new('--version-suffix', '--version-suffix', [CompletionResultType]::ParameterName, "Set the value of the `$(VersionSuffix) property to use when building the project.")
@@ -743,6 +741,8 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--verbosity', '-verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '/v', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '/verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
+                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.")
+                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.")
                 [CompletionResult]::new('--arch', '--arch', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--arch', '-a', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--os', '--os', [CompletionResultType]::ParameterName, "The target operating system.")
@@ -815,8 +815,6 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--ignore-failed-sources', '--ignore-failed-sources', [CompletionResultType]::ParameterName, "Treat package source failures as warnings.")
                 [CompletionResult]::new('--force', '--force', [CompletionResultType]::ParameterName, "Force all dependencies to be resolved even if the last restore was successful. This is equivalent to deleting project.assets.json.")
                 [CompletionResult]::new('--force', '-f', [CompletionResultType]::ParameterName, "Force all dependencies to be resolved even if the last restore was successful. This is equivalent to deleting project.assets.json.")
-                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to restore packages for.")
-                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to restore packages for.")
                 [CompletionResult]::new('--no-dependencies', '--no-dependencies', [CompletionResultType]::ParameterName, "Do not restore project-to-project references and only restore the specified project.")
                 [CompletionResult]::new('--verbosity', '--verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '-v', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
@@ -830,6 +828,8 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--no-logo', '--nologo', [CompletionResultType]::ParameterName, "Do not display the startup banner or the copyright message.")
                 [CompletionResult]::new('--no-logo', '-nologo', [CompletionResultType]::ParameterName, "Do not display the startup banner or the copyright message.")
                 [CompletionResult]::new('--no-logo', '/nologo', [CompletionResultType]::ParameterName, "Do not display the startup banner or the copyright message.")
+                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to restore packages for.")
+                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to restore packages for.")
                 [CompletionResult]::new('--arch', '--arch', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--arch', '-a', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--os', '--os', [CompletionResultType]::ParameterName, "The target operating system.")
@@ -845,8 +845,6 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--configuration', '-c', [CompletionResultType]::ParameterName, "The configuration to run for. The default for most projects is `'Debug`'.")
                 [CompletionResult]::new('--framework', '--framework', [CompletionResultType]::ParameterName, "The target framework to run for. The target framework must also be specified in the project file.")
                 [CompletionResult]::new('--framework', '-f', [CompletionResultType]::ParameterName, "The target framework to run for. The target framework must also be specified in the project file.")
-                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to run for.")
-                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to run for.")
                 [CompletionResult]::new('--project', '--project', [CompletionResultType]::ParameterName, "Defines the path of the project file to run. Use path to the project file, or path to the directory containing the project file. If not specified, it defaults to the current directory.")
                 [CompletionResult]::new('--file', '--file', [CompletionResultType]::ParameterName, "The path to the file-based app to run (can be also passed as the first argument if there is no project in the current directory).")
                 [CompletionResult]::new('--launch-profile', '--launch-profile', [CompletionResultType]::ParameterName, "The name of the launch profile (if any) to use when launching the application.")
@@ -865,6 +863,8 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--verbosity', '-verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '/v', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '/verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
+                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to run for.")
+                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to run for.")
                 [CompletionResult]::new('--arch', '--arch', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--arch', '-a', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--os', '--os', [CompletionResultType]::ParameterName, "The target operating system.")
@@ -996,8 +996,6 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--configuration', '-c', [CompletionResultType]::ParameterName, "The configuration to use for running tests. The default for most projects is `'Debug`'.")
                 [CompletionResult]::new('--framework', '--framework', [CompletionResultType]::ParameterName, "The target framework to run tests for. The target framework must also be specified in the project file.")
                 [CompletionResult]::new('--framework', '-f', [CompletionResultType]::ParameterName, "The target framework to run tests for. The target framework must also be specified in the project file.")
-                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to test for.")
-                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to test for.")
                 [CompletionResult]::new('--no-restore', '--no-restore', [CompletionResultType]::ParameterName, "Do not restore the project before building.")
                 [CompletionResult]::new('--interactive', '--interactive', [CompletionResultType]::ParameterName, "Allows the command to stop and wait for user input or action (for example to complete authentication).")
                 [CompletionResult]::new('--verbosity', '--verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
@@ -1006,6 +1004,8 @@ Register-ArgumentCompleter -Native -CommandName 'testhost' -ScriptBlock {
                 [CompletionResult]::new('--verbosity', '-verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '/v', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
                 [CompletionResult]::new('--verbosity', '/verbosity', [CompletionResultType]::ParameterName, "Set the MSBuild verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].")
+                [CompletionResult]::new('--runtime', '--runtime', [CompletionResultType]::ParameterName, "The target runtime to test for.")
+                [CompletionResult]::new('--runtime', '-r', [CompletionResultType]::ParameterName, "The target runtime to test for.")
                 [CompletionResult]::new('--arch', '--arch', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--arch', '-a', [CompletionResultType]::ParameterName, "The target architecture.")
                 [CompletionResult]::new('--os', '--os', [CompletionResultType]::ParameterName, "The target operating system.")
diff --git a/test/dotnet.Tests/CompletionTests/snapshots/zsh/DotnetCliSnapshotTests.VerifyCompletions.verified.zsh b/test/dotnet.Tests/CompletionTests/snapshots/zsh/DotnetCliSnapshotTests.VerifyCompletions.verified.zsh
index 3faf96cf701e..c217293bd8c3 100644
--- a/test/dotnet.Tests/CompletionTests/snapshots/zsh/DotnetCliSnapshotTests.VerifyCompletions.verified.zsh
+++ b/test/dotnet.Tests/CompletionTests/snapshots/zsh/DotnetCliSnapshotTests.VerifyCompletions.verified.zsh
@@ -41,8 +41,6 @@ _testhost() {
                         '-f=[The target framework to build for. The target framework must also be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
                         '--configuration=[The configuration to use for building the project. The default for most projects is '\''Debug'\''.]:CONFIGURATION:->dotnet_dynamic_complete' \
                         '-c=[The configuration to use for building the project. The default for most projects is '\''Debug'\''.]:CONFIGURATION:->dotnet_dynamic_complete' \
-                        '--runtime=[The target runtime to build for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
-                        '-r=[The target runtime to build for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--version-suffix=[Set the value of the \$(VersionSuffix) property to use when building the project.]:VERSION_SUFFIX: ' \
                         '--no-restore[Do not restore the project before building.]' \
                         '--interactive=[Allows the command to stop and wait for user input or action (for example to complete authentication).]: :((False\:"False" True\:"True" ))' \
@@ -65,6 +63,8 @@ _testhost() {
                         '--self-contained=[Publish the .NET runtime with your application so the runtime doesn'\''t need to be installed on the target machine. The default is '\''false.'\'' However, when targeting .NET 7 or lower, the default is '\''true'\'' if a runtime identifier is specified.]: :((False\:"False" True\:"True" ))' \
                         '--sc=[Publish the .NET runtime with your application so the runtime doesn'\''t need to be installed on the target machine. The default is '\''false.'\'' However, when targeting .NET 7 or lower, the default is '\''true'\'' if a runtime identifier is specified.]: :((False\:"False" True\:"True" ))' \
                         '--no-self-contained[Publish your application as a framework dependent application. A compatible .NET runtime must be installed on the target machine to run your application.]' \
+                        '--runtime=[The target runtime to build for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
+                        '-r=[The target runtime to build for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--arch=[The target architecture.]:ARCH: ' \
                         '-a=[The target architecture.]:ARCH: ' \
                         '--os=[The target operating system.]:OS: ' \
@@ -738,8 +738,6 @@ _testhost() {
                         '/nologo[Do not display the startup banner or the copyright message.]' \
                         '--framework=[The target framework to publish for. The target framework has to be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
                         '-f=[The target framework to publish for. The target framework has to be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
-                        '--runtime=[The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
-                        '-r=[The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--configuration=[The configuration to publish for. The default is '\''Release'\'' for NET 8.0 projects and above, but '\''Debug'\'' for older projects.]:CONFIGURATION:->dotnet_dynamic_complete' \
                         '-c=[The configuration to publish for. The default is '\''Release'\'' for NET 8.0 projects and above, but '\''Debug'\'' for older projects.]:CONFIGURATION:->dotnet_dynamic_complete' \
                         '--version-suffix=[Set the value of the \$(VersionSuffix) property to use when building the project.]:VERSION_SUFFIX: ' \
@@ -751,6 +749,8 @@ _testhost() {
                         '-verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '/v=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '/verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
+                        '--runtime=[The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
+                        '-r=[The target runtime to publish for. This is used when creating a self-contained deployment. The default is to publish a framework-dependent application.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--arch=[The target architecture.]:ARCH: ' \
                         '-a=[The target architecture.]:ARCH: ' \
                         '--os=[The target operating system.]:OS: ' \
@@ -850,8 +850,6 @@ _testhost() {
                         '--ignore-failed-sources[Treat package source failures as warnings.]' \
                         '--force[Force all dependencies to be resolved even if the last restore was successful. This is equivalent to deleting project.assets.json.]' \
                         '-f[Force all dependencies to be resolved even if the last restore was successful. This is equivalent to deleting project.assets.json.]' \
-                        '*--runtime=[The target runtime to restore packages for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
-                        '*-r=[The target runtime to restore packages for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--no-dependencies[Do not restore project-to-project references and only restore the specified project.]' \
                         '--verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '-v=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
@@ -865,6 +863,8 @@ _testhost() {
                         '--nologo[Do not display the startup banner or the copyright message.]' \
                         '-nologo[Do not display the startup banner or the copyright message.]' \
                         '/nologo[Do not display the startup banner or the copyright message.]' \
+                        '*--runtime=[The target runtime to restore packages for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
+                        '*-r=[The target runtime to restore packages for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--arch=[The target architecture.]:ARCH: ' \
                         '-a=[The target architecture.]:ARCH: ' \
                         '--os=[The target operating system.]:OS: ' \
@@ -889,8 +889,6 @@ _testhost() {
                         '-c=[The configuration to run for. The default for most projects is '\''Debug'\''.]:CONFIGURATION:->dotnet_dynamic_complete' \
                         '--framework=[The target framework to run for. The target framework must also be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
                         '-f=[The target framework to run for. The target framework must also be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
-                        '--runtime=[The target runtime to run for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
-                        '-r=[The target runtime to run for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--project=[Defines the path of the project file to run. Use path to the project file, or path to the directory containing the project file. If not specified, it defaults to the current directory.]:PROJECT_PATH: ' \
                         '--file=[The path to the file-based app to run (can be also passed as the first argument if there is no project in the current directory).]:FILE_PATH: ' \
                         '--launch-profile=[The name of the launch profile (if any) to use when launching the application.]:LAUNCH_PROFILE: ' \
@@ -909,6 +907,8 @@ _testhost() {
                         '-verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '/v=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '/verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
+                        '--runtime=[The target runtime to run for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
+                        '-r=[The target runtime to run for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--arch=[The target architecture.]:ARCH: ' \
                         '-a=[The target architecture.]:ARCH: ' \
                         '--os=[The target operating system.]:OS: ' \
@@ -1059,8 +1059,6 @@ _testhost() {
                         '-c=[The configuration to use for running tests. The default for most projects is '\''Debug'\''.]:CONFIGURATION:->dotnet_dynamic_complete' \
                         '--framework=[The target framework to run tests for. The target framework must also be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
                         '-f=[The target framework to run tests for. The target framework must also be specified in the project file.]:FRAMEWORK:->dotnet_dynamic_complete' \
-                        '--runtime=[The target runtime to test for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
-                        '-r=[The target runtime to test for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--no-restore[Do not restore the project before building.]' \
                         '--interactive=[Allows the command to stop and wait for user input or action (for example to complete authentication).]: :((False\:"False" True\:"True" ))' \
                         '--verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
@@ -1069,6 +1067,8 @@ _testhost() {
                         '-verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '/v=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
                         '/verbosity=[Set the MSBuild verbosity level. Allowed values are q\[uiet\], m\[inimal\], n\[ormal\], d\[etailed\], and diag\[nostic\].]:LEVEL:((d\:"d" detailed\:"detailed" diag\:"diag" diagnostic\:"diagnostic" m\:"m" minimal\:"minimal" n\:"n" normal\:"normal" q\:"q" quiet\:"quiet" ))' \
+                        '--runtime=[The target runtime to test for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
+                        '-r=[The target runtime to test for.]:RUNTIME_IDENTIFIER:->dotnet_dynamic_complete' \
                         '--arch=[The target architecture.]:ARCH: ' \
                         '-a=[The target architecture.]:ARCH: ' \
                         '--os=[The target operating system.]:OS: ' \

From c440cc52c3a34c6354cee918eb85e12726a5ab7f Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Tue, 6 Jan 2026 17:24:13 -0800
Subject: [PATCH 20/20] VSTest

---
 .../Test/TestCommandDefinition.VSTest.cs      |  4 +--
 .../Commands/Test/VSTest/TestCommand.cs       | 18 +++++-----
 .../dotnet/Commands/VSTest/VSTestCommand.cs   | 12 ++++---
 .../VSTest/VSTestCommandDefinition.cs         | 35 +++++++++++++++++++
 .../Commands/VSTest/VSTestCommandParser.cs    | 21 ++---------
 src/Cli/dotnet/CommonOptions.cs               | 12 -------
 src/Cli/dotnet/Telemetry/TelemetryFilter.cs   |  3 +-
 ...TestBuildsAndRunsArtifactPostProcessing.cs |  1 +
 8 files changed, 60 insertions(+), 46 deletions(-)
 create mode 100644 src/Cli/dotnet/Commands/VSTest/VSTestCommandDefinition.cs

diff --git a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
index 2f8ae4c3b5a2..51bbc3785d1b 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
@@ -24,7 +24,7 @@ public sealed class VSTest : TestCommandDefinition
             Arity = ArgumentArity.Zero
         }.ForwardAs("-property:VSTestListTests=true");
 
-        public readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.CreateEnvOption(CliStrings.CmdTestEnvironmentVariableDescription);
+        public readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CommonOptions.CreateEnvOption(CliStrings.CmdTestEnvironmentVariableDescription);
 
         public readonly Option<string> FilterOption = new Option<string>("--filter")
         {
@@ -163,7 +163,7 @@ public VSTest()
 
             Options.Add(SettingsOption);
             Options.Add(ListTestsOption);
-            Options.Add(EnvOption);
+            Options.Add(TestEnvOption);
             Options.Add(FilterOption);
             Options.Add(AdapterOption);
             Options.Add(LoggerOption);
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
index 951fec104150..2dc2bc8b6906 100644
--- a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
+++ b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
@@ -78,6 +78,8 @@ public static int Run(ParseResult parseResult)
 
     private static int ForwardToMsbuild(ParseResult parseResult, string[] settings, string testSessionCorrelationId)
     {
+        var definition = (TestCommandDefinition.VSTest)parseResult.CommandResult.Command;
+
         // Workaround for https://github.com/Microsoft/vstest/issues/1503
         const string NodeWindowEnvironmentName = "MSBUILDENSURESTDOUTFORTASKPROCESSES";
         string? previousNodeWindowSetting = Environment.GetEnvironmentVariable(NodeWindowEnvironmentName);
@@ -126,7 +128,7 @@ private static int ForwardToMsbuild(ParseResult parseResult, string[] settings,
             int exitCode = FromParseResult(parseResult, settings, testSessionCorrelationId, additionalBuildProperties).Execute();
 
             // We run post processing also if execution is failed for possible partial successful result to post process.
-            exitCode |= RunArtifactPostProcessingIfNeeded(testSessionCorrelationId, parseResult, FeatureFlag.Instance);
+            exitCode |= RunArtifactPostProcessingIfNeeded(testSessionCorrelationId, parseResult.GetValue(definition.DiagOption), FeatureFlag.Instance);
 
             return exitCode;
         }
@@ -148,6 +150,8 @@ static string[] SetLegacyVSTestWorkarounds(string NodeWindowEnvironmentName)
 
     private static int ForwardToVSTestConsole(ParseResult parseResult, string[] args, string[] settings, string testSessionCorrelationId)
     {
+        var definition = (TestCommandDefinition.VSTest)parseResult.CommandResult.Command;
+
         List<string> convertedArgs = new VSTestArgumentConverter().Convert(args, out List<string> ignoredArgs);
         if (ignoredArgs.Any())
         {
@@ -168,7 +172,7 @@ private static int ForwardToVSTestConsole(ParseResult parseResult, string[] args
         int exitCode = new VSTestForwardingApp(convertedArgs).Execute();
 
         // We run post processing also if execution is failed for possible partial successful result to post process.
-        exitCode |= RunArtifactPostProcessingIfNeeded(testSessionCorrelationId, parseResult, FeatureFlag.Instance);
+        exitCode |= RunArtifactPostProcessingIfNeeded(testSessionCorrelationId, parseResult.GetValue(definition.DiagOption), FeatureFlag.Instance);
 
         return exitCode;
     }
@@ -252,7 +256,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             msbuildPath);
 
         // Apply environment variables provided by the user via --environment (-e) option, if present
-        if (result.GetValue(definition.EnvOption) is { } environmentVariables)
+        if (result.GetValue(definition.TestEnvOption) is { } environmentVariables)
         {
             foreach (var (name, value) in environmentVariables)
             {
@@ -271,7 +275,7 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
         return testCommand;
     }
 
-    internal static int RunArtifactPostProcessingIfNeeded(string testSessionCorrelationId, ParseResult parseResult, FeatureFlag disableFeatureFlag)
+    internal static int RunArtifactPostProcessingIfNeeded(string testSessionCorrelationId, string? diag, FeatureFlag disableFeatureFlag)
     {
         if (disableFeatureFlag.IsSet(FeatureFlag.DISABLE_ARTIFACTS_POSTPROCESSING))
         {
@@ -290,11 +294,9 @@ internal static int RunArtifactPostProcessingIfNeeded(string testSessionCorrelat
 
         var artifactsPostProcessArgs = new List<string> { "--artifactsProcessingMode-postprocess", $"--testSessionCorrelationId:{testSessionCorrelationId}" };
 
-        var definition = (TestCommandDefinition.VSTest)parseResult.CommandResult.Command;
-
-        if (parseResult.GetResult(definition.DiagOption) is not null)
+        if (diag != null)
         {
-            artifactsPostProcessArgs.Add($"--diag:{parseResult.GetValue(definition.DiagOption)}");
+            artifactsPostProcessArgs.Add($"--diag:{diag}");
         }
 
         try
diff --git a/src/Cli/dotnet/Commands/VSTest/VSTestCommand.cs b/src/Cli/dotnet/Commands/VSTest/VSTestCommand.cs
index d13a367a8e87..89b5c352a822 100644
--- a/src/Cli/dotnet/Commands/VSTest/VSTestCommand.cs
+++ b/src/Cli/dotnet/Commands/VSTest/VSTestCommand.cs
@@ -35,21 +35,23 @@ public static int Run(ParseResult parseResult)
         int exitCode = vsTestforwardingApp.Execute();
 
         // We run post processing also if execution is failed for possible partial successful result to post process.
-        exitCode |= TestCommand.RunArtifactPostProcessingIfNeeded(testSessionCorrelationId, parseResult, FeatureFlag.Instance);
+        exitCode |= TestCommand.RunArtifactPostProcessingIfNeeded(testSessionCorrelationId, diag: null, FeatureFlag.Instance);
 
         return exitCode;
     }
 
     private static string[] GetArgs(ParseResult parseResult)
     {
+        var definition = (VSTestCommandDefinition)parseResult.CommandResult.Command;
+
         IEnumerable<string> args = parseResult.GetArguments();
 
-        if (parseResult.HasOption(CommonOptions.TestLoggerOption))
+        if (parseResult.HasOption(definition.TestLoggerOption))
         {
             // System command line might have mutated the options, reformat test logger option so vstest recognizes it
-            var loggerValues = parseResult.GetValue(CommonOptions.TestLoggerOption);
-            var loggerArgs = loggerValues.Select(loggerValue => $"{CommonOptions.TestLoggerOption.Name}:{loggerValue}");
-            args = args.Where(a => !loggerValues.Contains(a) && !CommonOptions.TestLoggerOption.Name.Equals(a) && !CommonOptions.TestLoggerOption.Aliases.Contains(a));
+            var loggerValues = parseResult.GetValue(definition.TestLoggerOption);
+            var loggerArgs = loggerValues.Select(loggerValue => $"{definition.TestLoggerOption.Name}:{loggerValue}");
+            args = args.Where(a => !loggerValues.Contains(a) && !definition.TestLoggerOption.Name.Equals(a) && !definition.TestLoggerOption.Aliases.Contains(a));
             args = loggerArgs.Concat(args);
         }
 
diff --git a/src/Cli/dotnet/Commands/VSTest/VSTestCommandDefinition.cs b/src/Cli/dotnet/Commands/VSTest/VSTestCommandDefinition.cs
new file mode 100644
index 000000000000..e2c8e6db1c86
--- /dev/null
+++ b/src/Cli/dotnet/Commands/VSTest/VSTestCommandDefinition.cs
@@ -0,0 +1,35 @@
+// 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 Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.VSTest;
+
+internal sealed class VSTestCommandDefinition : Command
+{
+    private const string Link = "https://aka.ms/dotnet-vstest";
+
+    public const string TestPlatformOptionName = "--Platform";
+
+    public readonly Option<string> TestPlatformOption = new(TestPlatformOptionName);
+
+    public const string TestFrameworkOptionName = "--Framework";
+
+    public readonly Option<string> TestFrameworkOption = new(TestFrameworkOptionName);
+
+    public const string TestLoggerOptionName = "--logger";
+
+    public readonly Option<string[]> TestLoggerOption = new(TestLoggerOptionName);
+
+    public VSTestCommandDefinition()
+        : base("vstest")
+    {
+        TreatUnmatchedTokensAsErrors = false;
+        this.DocsLink = Link;
+
+        Options.Add(TestPlatformOption);
+        Options.Add(TestFrameworkOption);
+        Options.Add(TestLoggerOption);
+    }
+}
diff --git a/src/Cli/dotnet/Commands/VSTest/VSTestCommandParser.cs b/src/Cli/dotnet/Commands/VSTest/VSTestCommandParser.cs
index 6a9e5fcb257f..5e7175bdec20 100644
--- a/src/Cli/dotnet/Commands/VSTest/VSTestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/VSTest/VSTestCommandParser.cs
@@ -1,38 +1,23 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.VSTest;
 
 internal static class VSTestCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-vstest";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly VSTestCommandDefinition Command = CreateCommand();
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static VSTestCommandDefinition CreateCommand()
     {
-        Command command = new("vstest")
-        {
-            TreatUnmatchedTokensAsErrors = false,
-            DocsLink = DocsLink
-        };
-
-        command.Options.Add(CommonOptions.TestPlatformOption);
-        command.Options.Add(CommonOptions.TestFrameworkOption);
-        command.Options.Add(CommonOptions.TestLoggerOption);
-
+        var command = new VSTestCommandDefinition();
         command.SetAction(VSTestCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index cfb1f2e994df..3f54e0d0db2c 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -338,18 +338,6 @@ private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(Arg
         return result;
     }
 
-    public const string TestPlatformOptionName = "--Platform";
-
-    public static readonly Option<string> TestPlatformOption = new(TestPlatformOptionName);
-
-    public const string TestFrameworkOptionName = "--Framework";
-
-    public static readonly Option<string> TestFrameworkOption = new(TestFrameworkOptionName);
-
-    public const string TestLoggerOptionName = "--logger";
-
-    public static readonly Option<string[]> TestLoggerOption = new(TestLoggerOptionName);
-
     /// <summary>
     /// Creates an implementation of the <c>--no-logo</c> option.
     /// This option suppresses the display of the startup banner or logos for commands or products it is applied to.
diff --git a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
index 3bd20c787b33..36d088115a01 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
@@ -13,6 +13,7 @@
 using Microsoft.DotNet.Cli.Commands.Publish;
 using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Commands.Test;
+using Microsoft.DotNet.Cli.Commands.VSTest;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
 
@@ -125,7 +126,7 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["vstest"],
-            optionsToLog: [CommonOptions.TestPlatformOptionName, CommonOptions.TestFrameworkOptionName, CommonOptions.TestLoggerOptionName]
+            optionsToLog: [VSTestCommandDefinition.TestPlatformOptionName, VSTestCommandDefinition.TestFrameworkOptionName, VSTestCommandDefinition.TestLoggerOptionName]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
diff --git a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsArtifactPostProcessing.cs b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsArtifactPostProcessing.cs
index 007c4b6b703a..59a7ff9ae531 100644
--- a/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsArtifactPostProcessing.cs
+++ b/test/dotnet.Tests/CommandTests/Test/GivenDotnetTestBuildsAndRunsArtifactPostProcessing.cs
@@ -89,6 +89,7 @@ public void ArtifactPostProcessing_VSTest_TestContainers(bool merge)
             CommandResult result = new DotnetVSTestCommand(Log)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .WithEnvironmentVariable(FeatureFlag.DISABLE_ARTIFACTS_POSTPROCESSING, "0")
+                                    .WithEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE", "1")
                                     .Execute(
                                         Directory.GetFiles(testInstance.Path, "test1.dll", SearchOption.AllDirectories).SingleOrDefault(x => x.Contains("publish")),
                                         Directory.GetFiles(testInstance.Path, "test2.dll", SearchOption.AllDirectories).SingleOrDefault(x => x.Contains("publish")),