diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
index 99886ae33f91..a36d6a8b9351 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.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
+            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..c97289de5f88 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.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
+                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 199e16e5bb58..65bb225e8de4 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -8,88 +8,94 @@
 
 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 Option<string> OutputOption = new Option<string>("--output", "-o")
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+
+    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.NoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
-    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.CreateSelfContainedOption();
 
-    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.CreateNoSelfContainedOption();
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.BuildRuntimeOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(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.MSBuildTargetOption();
-
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
-
-    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<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);
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: false);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.DebugOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.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.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
-
-        return command;
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        ImplicitRestoreOptions.AddTo(Options);
+        Options.Add(FrameworkOption);
+        Options.Add(ConfigurationOption);
+        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);
+        TargetPlatformOptions.AddTo(Options);
+        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..490189bac558 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
@@ -2,21 +2,24 @@
 // 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;
 
 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);
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
index e2074b7a7d58..ee22ae1d3900 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.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
+                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 f04aa32b658b..272a005d7b30 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
@@ -8,56 +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.NoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("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 Command Create()
+    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();
+    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 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(CommonOptions.RuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription));
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        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.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 8d857d8383e8..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,19 +23,19 @@ 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],
             [
                 .. 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));
+            return createVirtualCommand(msbuildArgs, Path.GetFullPath(arg));
         }
         else
         {
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
index 9ddc79a80e47..3523f44f4342 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
@@ -13,14 +13,14 @@ 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.
         // 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..350e72607a75 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
@@ -11,7 +11,8 @@ 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 readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
 
     public static Command Create()
     {
@@ -21,7 +22,7 @@ public static Command Create()
             DocsLink = DocsLink,
         };
 
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(DisableBuildServersOption);
         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..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.MSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.NoLogoOption()),
+        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 fe36ed860367..bba916eb775f 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)
@@ -56,20 +57,20 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 msbuildPath),
             optionsToUseWhenParsingMSBuildFlags:
             [
-                CommonOptions.PropertiesOption,
-                CommonOptions.RestorePropertiesOption,
-                PackCommandDefinition.TargetOption,
-                PackCommandDefinition.VerbosityOption,
-                PackCommandDefinition.NoLogoOption
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
+                PackCommandDefinition.CreateTargetOption(),
+                CommonOptions.CreateVerbosityOption(),
+                CommonOptions.CreateNoLogoOption()
             ],
             parseResult,
             msbuildPath,
-            (msbuildArgs) =>
+            transformer: (msbuildArgs) =>
             {
-                ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
+                ReleasePropertyProjectLocator projectLocator = new(msbuildArgs.GlobalProperties, 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 100b5e42cc39..1f321198a7c0 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -9,106 +9,119 @@
 
 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)
+    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 ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+
+    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.NoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
+
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<string[]> TargetOption = CreateTargetOption();
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
+    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 = TargetPlatformOptions.CreateRuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
 
-    public static Option<NuGetVersion> VersionOption =
-        new Option<NuGetVersion>("--version")
+    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 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(CommonOptions.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.InteractiveMsBuildForwardOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
-        command.Options.Add(VersionOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        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);
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
-
-        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);
     }
+
+    public static Option<string[]> CreateTargetOption()
+        => CommonOptions.CreateRequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
 }
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;
     }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
index 19568315c08c..db75885e6da0 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,17 +60,24 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 noRestore: noRestore,
                 msbuildPath: msbuildPath
             ),
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, PublishCommandDefinition.TargetOption, PublishCommandDefinition.VerbosityOption, PublishCommandDefinition.NoLogoOption],
+            optionsToUseWhenParsingMSBuildFlags:
+            [
+                CommonOptions.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
+                PublishCommandDefinition.CreateTargetOption(),
+                CommonOptions.CreateVerbosityOption(),
+                CommonOptions.CreateNoLogoOption()
+            ],
             parseResult,
             msbuildPath,
-            (msbuildArgs) =>
+            transformer: (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 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 19603b0b7cbb..7fcf76edb936 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -3,91 +3,99 @@
 
 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;
 
 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 Option<string> OutputOption = new Option<string>("--output", "-o")
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: false, useShortOptions: false);
+
+    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.NoLogoOption();
+    public readonly Option<bool> NoLogoOption = CommonOptions.CreateNoLogoOption();
+
+    public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
 
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+    public readonly Option<bool> SelfContainedOption = CommonOptions.CreateSelfContainedOption();
 
-    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.CreateNoSelfContainedOption();
 
-    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.PublishRuntimeOptionDescription);
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
+    public readonly Option<string[]> TargetOption = CreateTargetOption();
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
+    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<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);
-        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
-
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.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(CommonOptions.VersionSuffixOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        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(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.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(ConfigurationOption);
+        Options.Add(VersionSuffixOption);
+        Options.Add(InteractiveOption);
+        Options.Add(NoRestoreOption);
+        Options.Add(VerbosityOption);
+        TargetPlatformOptions.AddTo(Options);
+        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..3ef720071949 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
@@ -2,21 +2,24 @@
 // 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;
 
 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);
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs b/src/Cli/dotnet/Commands/Restore/ImplicitRestoreOptions.cs
new file mode 100644
index 000000000000..379f2a6db850
--- /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.CreateUseCurrentRuntimeOption(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.CreatePropertyOption();
+        RestorePropertiesOption = CommonOptions.CreateRestorePropertyOption();
+    }
+
+    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/RestoreCommand.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
index f0e3fdff688b..a79d38066986 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.CreatePropertyOption(),
+                CommonOptions.CreateRestorePropertyOption(),
+                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 429df87574a8..89ea3794459a 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -4,91 +4,97 @@
 using System.CommandLine;
 using System.CommandLine.StaticCompletions;
 using Microsoft.DotNet.Cli.CommandLine;
-using NuGet.Packaging;
 
 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 Option<IEnumerable<string>> SourceOption = new Option<IEnumerable<string>>("--source", "-s")
+    public readonly ImplicitRestoreOptions ImplicitRestoreOptions = new(showHelp: true, useShortOptions: true);
+
+    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 readonly Option<bool> DisableBuildServersOption = CommonOptions.CreateDisableBuildServersOption();
+
+    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();
+
+    public readonly Option<bool> UseLockFileOption = new Option<bool>("--use-lock-file")
     {
-        Description = CliCommandStrings.CmdSourceOptionDescription,
-        HelpName = CliCommandStrings.CmdSourceOption
-    }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")
-    .AllowSingleArgPerToken();
-
-    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),
-        VerbosityOption,
-        CommonOptions.InteractiveMsBuildForwardOption,
-        CommonOptions.ArtifactsPathOption,
-        new Option<bool>("--use-lock-file")
-        {
-            Description = CliCommandStrings.CmdUseLockFileOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestorePackagesWithLockFile=true"),
-        new Option<bool>("--locked-mode")
-        {
-            Description = CliCommandStrings.CmdLockedModeOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreLockedMode=true"),
-        new Option<string>("--lock-file-path")
-        {
-            Description = CliCommandStrings.CmdLockFilePathOptionDescription,
-            HelpName = CliCommandStrings.CmdLockFilePathOption
-        }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}"),
-        new Option<bool>("--force-evaluate")
-        {
-            Description = CliCommandStrings.CmdReevaluateOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreForceEvaluate=true"),
-        TargetOption,
-        NoLogoOption
-    ];
-
-    public static Command Create()
+        Description = CliCommandStrings.CmdUseLockFileOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:RestorePackagesWithLockFile=true");
+
+    public readonly Option<bool> LockedModeOption = new Option<bool>("--locked-mode")
     {
-        var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
-        {
-            DocsLink = DocsLink
-        };
+        Description = CliCommandStrings.CmdLockedModeOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:RestoreLockedMode=true");
 
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
+    public readonly Option<string> LockFilePathOption = new Option<string>("--lock-file-path")
+    {
+        Description = CliCommandStrings.CmdLockFilePathOptionDescription,
+        HelpName = CliCommandStrings.CmdLockFilePathOption
+    }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}");
 
-        command.Options.AddRange(FullRestoreOptions());
+    public readonly Option<bool> ForceEvaluateOption = new Option<bool>("--force-evaluate")
+    {
+        Description = CliCommandStrings.CmdReevaluateOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:RestoreForceEvaluate=true");
 
-        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);
+    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();
 
-        return command;
-    }
-
-    public static void AddImplicitRestoreOptions(Command command, bool showHelp = false, bool useShortOptions = false, bool includeRuntimeOption = true, bool includeNoDependenciesOption = true)
+    public RestoreCommandDefinition()
+        : base("restore", CliCommandStrings.RestoreAppFullName)
     {
-        foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions, includeRuntimeOption, includeNoDependenciesOption))
-        {
-            command.Options.Add(option);
-        }
+        this.DocsLink = Link;
+
+        Arguments.Add(SlnOrProjectOrFileArgument);
+        Options.Add(DisableBuildServersOption);
+
+        ImplicitRestoreOptions.AddTo(Options);
+
+        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);
+
+        TargetPlatformOptions.AddTo(Options);
+
+        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 = [];
@@ -106,117 +112,29 @@ 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>> CreateRuntimeOption()
     {
-        if (showHelp && useShortOptions)
-        {
-            yield return SourceOption;
-        }
-        else
-        {
-            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();
-
-            if (useShortOptions)
-            {
-                sourceOption.Aliases.Add("-s");
-            }
-
-            yield return sourceOption;
-        }
-
-        yield return new Option<string>("--packages")
+        Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime", "-r")
         {
-            Description = showHelp ? CliCommandStrings.CmdPackagesOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdPackagesOption,
-            Hidden = !showHelp
-        }.ForwardAsSingle(o => $"-property:RestorePackagesPath={CommandDirectoryContext.GetFullPath(o)}");
+            Description = CliCommandStrings.CmdRuntimeOptionDescription,
+            HelpName = CliCommandStrings.CmdRuntimeOption,
+            IsDynamic = true
+        }.ForwardAsSingle(RestoreRuntimeArgFunc)
+         .AllowSingleArgPerToken()
+         .AddCompletions(CliCompletion.RunTimesFromProjectFile);
 
-        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");
+        return runtimeOption;
+    }
 
-        yield return new Option<string>("--configfile")
+    public static Option<bool> CreateNoDependenciesOption(bool showHelp)
+        => new Option<bool>("--no-dependencies")
         {
-            Description = showHelp ? CliCommandStrings.CmdConfigFileOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdConfigFileOption,
+            Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
+            Arity = ArgumentArity.Zero,
             Hidden = !showHelp
-        }.ForwardAsSingle(o => $"-property:RestoreConfigFile={CommandDirectoryContext.GetFullPath(o)}");
+        }.ForwardAs("-property:RestoreRecursive=false");
 
-        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");
+    public static Option<string[]> CreateTargetOption() => CommonOptions.CreateRequiredMSBuildTargetOption("Restore");
 
-        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;
-
-        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;
-        }
-
-        if (includeNoDependenciesOption)
-        {
-            yield return new Option<bool>("--no-dependencies")
-            {
-                Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
-                Arity = ArgumentArity.Zero,
-                Hidden = !showHelp
-            }.ForwardAs("-property:RestoreRecursive=false");
-        }
-    }
 }
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/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 4a0b48ddb7df..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,14 +118,13 @@ public RunCommand(
         NoCache = noCache;
         MSBuildArgs = SetupSilentBuildArgs(msbuildArgs);
         EnvironmentVariables = environmentVariables;
-        RestoreProperties = msbuildRestoreProperties;
     }
 
     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 +684,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 +696,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 +712,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 +728,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 +737,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,26 +761,47 @@ 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.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
+            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,
-            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;
+
+        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 4fe24c881e43..8e5f9cdc3f16 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -7,105 +7,109 @@
 
 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.ConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
 
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
+    public readonly TargetPlatformOptions TargetPlatformOptions = new(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.CreatePropertyOption();
 
-    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.CreateNoRestoreOption();
+
+    public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
 
-    public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
+    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<bool> SelfContainedOption = CommonOptions.CreateSelfContainedOption();
+
+    public readonly Option<bool> NoSelfContainedOption = CommonOptions.CreateNoSelfContainedOption();
+
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+
+    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.CreateEnvOption();
 
-    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.DisableBuildServersOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(CommonOptions.EnvOption);
-
-        command.Arguments.Add(ApplicationArguments);
-
-        return command;
+        this.DocsLink = Link;
+
+        Options.Add(ConfigurationOption);
+        Options.Add(FrameworkOption);
+        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);
+        TargetPlatformOptions.AddTo(Options);
+        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..da64925a6c9f 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
@@ -2,21 +2,24 @@
 // 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;
 
 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);
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs b/src/Cli/dotnet/Commands/Test/MTP/MSBuildUtility.cs
index 3b8d5494a143..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.MSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.NoLogoOption());
+        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.MSBuildTargetOption(), CommonOptions.CreateVerbosityOption(), CommonOptions.NoLogoOption());
+        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);
@@ -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.NoLogoOption());
+        var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
+            msbuildArgs,
+            CommonOptions.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
+            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
deleted file mode 100644
index fff37275fd84..000000000000
--- a/src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs
+++ /dev/null
@@ -1,116 +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 static readonly Option<string> ResultsDirectoryOption = new("--results-directory")
-    {
-        Description = CliCommandStrings.CmdResultsDirectoryDescription,
-        HelpName = CliCommandStrings.CmdPathToResultsDirectory,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public static readonly Option<string> ConfigFileOption = new("--config-file")
-    {
-        Description = CliCommandStrings.CmdConfigFileDescription,
-        HelpName = CliCommandStrings.CmdConfigFilePath,
-        Arity = ArgumentArity.ExactlyOne
-    };
-
-    public static readonly Option<string> DiagnosticOutputDirectoryOption = new("--diagnostic-output-directory")
-    {
-        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 static readonly Option<string> ListTestsOption = new("--list-tests")
-    {
-        Description = CliCommandStrings.CmdListTestsDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<string[]> MTPTargetOption = CommonOptions.RequiredMSBuildTargetOption(CliConstants.MTPTarget);
-}
-
-internal enum OutputOptions
-{
-    Normal,
-    Detailed
-}
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..63d307b39fd6 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
@@ -37,18 +30,20 @@ public int Run(ParseResult parseResult, bool isHelp = false)
 
     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)
         {
@@ -87,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;
@@ -100,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);
@@ -116,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) =>
@@ -132,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/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 be7a7371c707..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.ListTestsOption.Name}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.ListTestsOptionName}");
         }
 
         if (_buildOptions.PathOptions.ResultsDirectoryPath is { } resultsDirectoryPath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ResultsDirectoryOption.Name} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.ResultsDirectoryOptionName} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
         }
 
         if (_buildOptions.PathOptions.ConfigFilePath is { } configFilePath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.ConfigFileOption.Name} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
+            builder.Append($" {TestCommandDefinition.MicrosoftTestingPlatform.ConfigFileOptionName} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
         }
 
         if (_buildOptions.PathOptions.DiagnosticOutputDirectoryPath is { } diagnosticOutputDirectoryPath)
         {
-            builder.Append($" {MicrosoftTestingPlatformOptions.DiagnosticOutputDirectoryOption.Name} {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/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..6751f5c2e3d4 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.TargetPlatformOptions.ArchitectureOption) ||
+                parseResult.HasOption(definition.ConfigurationOption) ||
+                parseResult.HasOption(definition.FrameworkOption) ||
+                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
new file mode 100644
index 000000000000..f7a6931a7664
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.MicrosoftTestingPlatform.cs
@@ -0,0 +1,164 @@
+// 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<IReadOnlyDictionary<string, string>> EnvOption = CommonOptions.CreateEnvOption();
+
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.CreatePropertyOption();
+
+        public readonly Option<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
+
+        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(EnvOption);
+            Options.Add(PropertiesOption);
+            Options.Add(ConfigurationOption);
+            Options.Add(FrameworkOption);
+            TargetPlatformOptions.AddTo(Options);
+            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..51bbc3785d1b
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.VSTest.cs
@@ -0,0 +1,195 @@
+// 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.CreateEnvOption(CliStrings.CmdTestEnvironmentVariableDescription);
+
+        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<bool> NoRestoreOption = CommonOptions.CreateNoRestoreOption();
+
+        public readonly Option<bool> InteractiveOption = CommonOptions.CreateInteractiveMsBuildForwardOption();
+
+        public readonly Option<ReadOnlyDictionary<string, string>?> PropertiesOption = CommonOptions.CreatePropertyOption();
+
+        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(NoRestoreOption);
+            Options.Add(InteractiveOption);
+            Options.Add(VerbosityOption);
+            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 99282efc76b2..137a1e0c422c 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandDefinition.cs
@@ -9,41 +9,31 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
-internal static class TestCommandDefinition
+internal abstract partial class TestCommandDefinition : Command
 {
-    public enum TestRunner
-    {
-        VSTest,
-        MicrosoftTestingPlatform
-    }
+    private const string Link = "https://aka.ms/dotnet-test";
 
-    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 readonly TargetPlatformOptions TargetPlatformOptions = new(CliCommandStrings.TestRuntimeOptionDescription);
 
-    public const string Name = "test";
-    public static readonly string DocsLink = "https://aka.ms/dotnet-test";
+    public readonly Option<string> FrameworkOption = CommonOptions.CreateFrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
 
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.TestFrameworkOptionDescription);
+    public readonly Option<string?> ConfigurationOption = CommonOptions.CreateConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
 
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.TestConfigurationOptionDescription);
+    public readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
 
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.CreateVerbosityOption();
+    public TestCommandDefinition(string description)
+        : base("test", description)
+    {
+        this.DocsLink = Link;
+        TreatUnmatchedTokensAsErrors = false;
+    }
 
-    public static TestRunner GetTestRunner()
+    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,19 @@ public static TestRunner GetTestRunner()
 
             directory = Path.GetDirectoryName(directory);
         }
+
         return null;
     }
 
-    public static void ConfigureMicrosoftTestingPlatformCommand(Command command)
+    private sealed class GlobalJsonModel
     {
-        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.RuntimeOption(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);
+        [JsonPropertyName("test")]
+        public GlobalJsonTestNode Test { get; set; } = null!;
     }
 
-    public static void ConfigureVSTestCommand(Command command)
+    private sealed class GlobalJsonTestNode
     {
-        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.ArtifactsPathOption);
-        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.RuntimeOption(CliCommandStrings.TestRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.NoRestoreOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        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(VSTestOptions.VsTestTargetOption);
+        [JsonPropertyName("runner")]
+        public string RunnerName { get; set; } = null!;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
index 57300d5ee0ff..427f86d9fcb3 100644
--- a/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Test/TestCommandParser.cs
@@ -1,42 +1,42 @@
 // 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;
 
 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();
+
+        command.TargetPlatformOptions.RuntimeOption.AddCompletions(CliCompletion.RunTimesFromProjectFile);
+
+        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;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs b/src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs
index 7ef075d87530..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;
     }
@@ -189,6 +193,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 +206,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 +222,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,15 +239,15 @@ 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.NoLogoOption())
+            CommonOptions.CreatePropertyOption(),
+            CommonOptions.CreateRestorePropertyOption(),
+            CommonOptions.CreateRequiredMSBuildTargetOption("VSTest"),
+            CommonOptions.CreateVerbosityOption(),
+            CommonOptions.CreateNoLogoOption())
             .CloneWithNoLogo(true);
 
         TestCommand testCommand = new(
@@ -250,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(CommonOptions.TestEnvOption) is { } environmentVariables)
+        if (result.GetValue(definition.TestEnvOption) is { } environmentVariables)
         {
             foreach (var (name, value) in environmentVariables)
             {
@@ -269,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))
         {
@@ -288,9 +294,9 @@ internal static int RunArtifactPostProcessingIfNeeded(string testSessionCorrelat
 
         var artifactsPostProcessArgs = new List<string> { "--artifactsProcessingMode-postprocess", $"--testSessionCorrelationId:{testSessionCorrelationId}" };
 
-        if (parseResult.GetResult(VSTestOptions.DiagOption) is not null)
+        if (diag != null)
         {
-            artifactsPostProcessArgs.Add($"--diag:{parseResult.GetValue(VSTestOptions.DiagOption)}");
+            artifactsPostProcessArgs.Add($"--diag:{diag}");
         }
 
         try
diff --git a/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs b/src/Cli/dotnet/Commands/Test/VSTest/VSTestOptions.cs
index 05b018a485b1..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.NoLogoOption(forwardAs: "--property:VSTestNoLogo=true", description: CliCommandStrings.TestCmdNoLogo);
-
-    public static readonly Option<string[]> VsTestTargetOption = CommonOptions.RequiredMSBuildTargetOption("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()];
diff --git a/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Tool/Common/Store/StoreCommandDefinition.cs
index 8dd53310f4f5..74d694c246f2 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 = 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();
+    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.FrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription));
-        command.Options.Add(CommonOptions.RuntimeOption(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(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/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 a7e5b79143e6..3f54e0d0db2c 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;
@@ -21,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")
         {
@@ -29,14 +28,14 @@ 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)
     /// </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")
         {
@@ -66,7 +65,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 +78,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 +106,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,8 +167,10 @@ public static Option<VerbosityOptions> CreateHiddenVerbosityOption() =>
         .ForwardAsSingle(o => $"--verbosity:{o}")
         .AggregateRepeatedTokens();
 
-    public static Option<string> FrameworkOption(string description) =>
-        new Option<string>("--framework", "-f")
+    public const string FrameworkOptionName = "--framework";
+
+    public static Option<string> CreateFrameworkOption(string description) =>
+        new Option<string>(FrameworkOptionName, "-f")
         {
             Description = description,
             HelpName = CliStrings.FrameworkArgumentName,
@@ -178,7 +179,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")
@@ -187,44 +188,17 @@ public static Option<string> FrameworkOption(string description) =>
             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> RuntimeOption(string description) =>
-        new Option<string>(RuntimeOptionName, "-r")
-        {
-            HelpName = RuntimeArgName,
-            Description = description,
-            IsDynamic = true
-        }.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) =>
-        new Option<string?>("--configuration", "-c")
+    public const string ConfigurationOptionName = "--configuration";
+
+    public static Option<string?> CreateConfigurationOption(string description) =>
+        new Option<string?>(ConfigurationOptionName, "-c")
         {
             Description = description,
             HelpName = CliStrings.ConfigurationArgumentName,
@@ -232,7 +206,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,
@@ -249,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.",
@@ -287,9 +260,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,
@@ -297,45 +272,19 @@ public static Option<bool> CreateInteractiveOption(bool acceptArgument = false,
         }
         .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> 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")
-        {
-            Description = CliStrings.OperatingSystemOptionDescription,
-            HelpName = CliStrings.OSArgumentName
-        }.SetForwardingFunction(ResolveOsOptionToRuntimeIdentifier);
-
     public static Option<bool> DebugOption = new("--debug")
     {
         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,
@@ -343,19 +292,15 @@ public static Option<bool> CreateInteractiveOption(bool acceptArgument = false,
         }
         .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>(
@@ -393,12 +338,6 @@ private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(Arg
         return result;
     }
 
-    public static readonly Option<string> TestPlatformOption = new("--Platform");
-
-    public static readonly Option<string> TestFrameworkOption = new("--Framework");
-
-    public static readonly Option<string[]> TestLoggerOption = new("--logger");
-
     /// <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.
@@ -410,7 +349,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")
         {
@@ -428,71 +367,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() ? ArchOptionValue(parseResult) : 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 eb87125030f0..9ee171d6868c 100644
--- a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
@@ -170,28 +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.LongFormArchitectureOption)) &&
-        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/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/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 76c30928a112..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;
 
@@ -110,32 +111,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, TargetPlatformOptions.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: [VSTestCommandDefinition.TestPlatformOptionName, VSTestCommandDefinition.TestFrameworkOptionName, VSTestCommandDefinition.TestLoggerOptionName]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["publish"],
-            optionsToLog: [PublishCommandDefinition.RuntimeOption]
+            optionsToLog: [TargetPlatformOptions.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-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/MSBuild/GivenDotnetRunInvocation.cs b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
index 8ddf0e1d9ea5..6f646dda91fc 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.MSBuildTargetOption(), RunCommandDefinition.VerbosityOption, CommonOptions.NoLogoOption()));
+                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments(
+                        [
+                           .. ConstantRestoreArgs,
+                           .. expectedArgs,
+                           NuGetDisabledProperty
+                        ],
+                        options:
+                        [
+                            CommonOptions.CreatePropertyOption(),
+                            CommonOptions.CreateRestorePropertyOption(),
+                            CommonOptions.CreateMSBuildTargetOption(),
+                            CommonOptions.CreateVerbosityOption(),
+                            CommonOptions.CreateNoLogoOption()
+                        ]));
                 });
             }
             finally
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/Restore/RestoreParserTests.cs b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
index ae8c54776d9f..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.SourceOption)
+            restore.GetValue(definition.ImplicitRestoreOptions.SourceOption)
                 .Should()
                 .BeEquivalentTo(
                     "https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json",
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/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>
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/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")),
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..033d929a9e1f 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,8 +443,8 @@ public void RunningWithGlobalPropertyShouldProperlyPropagate(string configuratio
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
-                                        TestCommandDefinition.ConfigurationOption.Name, configuration,
-                                        CommonOptions.PropertiesOption.Name, "PROPERTY_TO_ENABLE_MTP=1");
+                                        "-c", configuration,
+                                        "--property", "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,8 +570,8 @@ public void RunTestProjectWithEnvVariable(string configuration)
             CommandResult result = new DotnetTestCommand(Log, disableNewOutput: false)
                                     .WithWorkingDirectory(testInstance.Path)
                                     .Execute(
-                                        TestCommandDefinition.ConfigurationOption.Name, configuration,
-                                        CommonOptions.EnvOption.Name, "DUMMY_TEST_ENV_VAR=ENV_VAR_CMD_LINE");
+                                        "-c", configuration,
+                                        "--environment", "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..08ae170e6db3 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())
             {
@@ -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)
             {
@@ -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..d8ba31c264eb 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,10 +221,10 @@ 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);
+            string runtime = TargetPlatformOptions.ResolveRidShorthandOptionsToRuntimeIdentifier(string.Empty, arch);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -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())
             {
@@ -265,12 +265,12 @@ 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,
-                                             TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--runtime", runtime,
+                                             "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -285,13 +285,13 @@ 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,
-                                            CommonOptions.ArchitectureOption.Name, arch,
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--runtime", runtime,
+                                            "--arch", arch,
+                                            "--configuration", configuration);
 
             result.ExitCode.Should().Be(ExitCodes.GenericFailure);
         }
@@ -303,12 +303,12 @@ 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],
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--os", runtime.Split('-')[0],
+                                            "--configuration", configuration);
 
             Assert.Matches(RegexPatternHelper.GenerateProjectRegexPattern("TestProject", TestingConstants.Passed, true, configuration, runtime: runtime), result.StdOut);
 
@@ -323,13 +323,13 @@ 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],
-                                            CommonOptions.ArchitectureOption.Name, arch,
-                                            TestCommandDefinition.ConfigurationOption.Name, configuration);
+                                    .Execute("--os", runtime.Split('-')[0],
+                                            "--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");
         }
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/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]
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: ' \
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]);