From 0c49f80a6665dd92304e83a8920046336a9b5bd9 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]" <dotnet-maestro[bot]@users.noreply.github.com>
Date: Thu, 23 Jan 2025 05:01:31 +0000
Subject: [PATCH 1/4] Update dependencies from
 https://github.com/dotnet/command-line-api build 20250122.1

Microsoft.SourceBuild.Intermediate.command-line-api , System.CommandLine , System.CommandLine.Rendering
 From Version 0.1.607102 -> To Version 0.1.607201
---
 eng/Version.Details.xml | 12 ++++++------
 eng/Versions.props      |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 37c1b11d5474..916a1e65287a 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -433,13 +433,13 @@
       <Sha>45caa455b34553e7ef3ff7cb1def454eef78037c</Sha>
       <SourceBuild RepoName="roslyn-analyzers" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="System.CommandLine" Version="2.0.0-beta4.25071.2">
+    <Dependency Name="System.CommandLine" Version="2.0.0-beta4.25072.1">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>3bbb940ceeb3254790899d751a8d418348563d40</Sha>
+      <Sha>060374e56c1b2e741b6525ca8417006efb54fbd7</Sha>
     </Dependency>
-    <Dependency Name="System.CommandLine.Rendering" Version="0.4.0-alpha.25071.2">
+    <Dependency Name="System.CommandLine.Rendering" Version="0.4.0-alpha.25072.1">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>3bbb940ceeb3254790899d751a8d418348563d40</Sha>
+      <Sha>060374e56c1b2e741b6525ca8417006efb54fbd7</Sha>
     </Dependency>
     <!-- Microsoft.CodeAnalysis.Workspaces.MSBuild transitively references M.Bcl.AsyncInterfaces.
          Adding an explicit dependency to make sure the latest version is used instead of the SBRP
@@ -450,9 +450,9 @@
       <Sha>ff1852196a042a124267a6e599d12da20d7ff65a</Sha>
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.command-line-api" Version="0.1.607102">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.command-line-api" Version="0.1.607201">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>3bbb940ceeb3254790899d751a8d418348563d40</Sha>
+      <Sha>060374e56c1b2e741b6525ca8417006efb54fbd7</Sha>
       <SourceBuild RepoName="command-line-api" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
diff --git a/eng/Versions.props b/eng/Versions.props
index 40bfcbdad4ce..32a0a9eeb35d 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -57,8 +57,8 @@
     <SystemDataSqlClientPackageVersion>4.8.6</SystemDataSqlClientPackageVersion>
     <StyleCopAnalyzersPackageVersion>1.2.0-beta.435</StyleCopAnalyzersPackageVersion>
     <WebDeploymentPackageVersion>4.0.5</WebDeploymentPackageVersion>
-    <SystemCommandLineVersion>2.0.0-beta4.25071.2</SystemCommandLineVersion>
-    <SystemCommandLineRenderingVersion>0.4.0-alpha.25071.2</SystemCommandLineRenderingVersion>
+    <SystemCommandLineVersion>2.0.0-beta4.25072.1</SystemCommandLineVersion>
+    <SystemCommandLineRenderingVersion>0.4.0-alpha.25072.1</SystemCommandLineRenderingVersion>
     <MicrosoftDeploymentDotNetReleasesVersion>2.0.0-preview.1.25063.2</MicrosoftDeploymentDotNetReleasesVersion>
     <MicrosoftDiaSymReaderVersion>2.2.0-beta.24622.1</MicrosoftDiaSymReaderVersion>
     <MicrosoftCodeAnalysisAnalyzerTestingVersion>1.1.2-beta1.22216.1</MicrosoftCodeAnalysisAnalyzerTestingVersion>

From 90f51081f78a218ba1bd443dec66fc994e3099e4 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 22 Jan 2025 18:03:51 +0100
Subject: [PATCH 2/4] adjust to System.CommandLine renaming

---
 src/BlazorWasmSdk/Tool/Program.cs             |  10 +-
 .../Commands/FormatAnalyzersCommand.cs        |   6 +-
 .../Commands/FormatCommandCommon.cs           |  30 ++--
 .../Commands/FormatStyleCommand.cs            |   6 +-
 .../Commands/FormatWhitespaceCommand.cs       |   6 +-
 .../Commands/RootFormatCommand.cs             |   6 +-
 .../dotnet-watch/CommandLineOptions.cs        |  32 ++--
 .../ChoiceTemplateParameter.cs                |   4 +-
 .../CliTemplateParameter.cs                   |  32 ++--
 .../Commands/BaseCommand.cs                   |  19 ++-
 .../Commands/CommandLineUtils.cs              |  16 +-
 .../Commands/Example.cs                       |  34 ++--
 .../Commands/Extensions.cs                    |  10 +-
 .../Commands/FilterOptionDefinition.cs        |   8 +-
 .../Commands/GlobalArgs.cs                    |   2 +-
 .../Commands/ICommandArgs.cs                  |   4 +-
 .../Commands/ICommandDocument.cs              |   2 +-
 .../Commands/ICustomHelp.cs                   |   2 +-
 .../Commands/IFilterableCommand.cs            |   2 +-
 .../Commands/ITabularOutputCommand.cs         |   4 +-
 .../Commands/NewCommand.Legacy.cs             |  32 ++--
 .../Commands/NewCommand.cs                    |  18 +-
 .../Commands/NewCommandArgs.cs                |   2 +-
 .../Commands/ParserFactory.cs                 |   4 +-
 .../Commands/SharedOptions.cs                 |  14 +-
 .../Commands/SharedOptionsFactory.cs          |  34 ++--
 .../create/InstantiateCommand.Help.cs         |  27 +--
 .../InstantiateCommand.NoMatchHandling.cs     |  12 +-
 .../InstantiateCommand.TabCompletion.cs       |   2 +-
 .../Commands/create/InstantiateCommand.cs     |   8 +-
 .../Commands/create/TemplateCommand.cs        |  19 ++-
 .../Commands/create/TemplateCommandArgs.cs    |   8 +-
 .../Commands/create/TemplateOption.cs         |   4 +-
 .../Commands/details/DetailsCommand.cs        |   8 +-
 .../Commands/install/BaseInstallCommand.cs    |   8 +-
 .../Commands/install/LegacyInstallCommand.cs  |   6 +-
 .../Commands/list/BaseListCommand.cs          |  10 +-
 .../Commands/list/LegacyListCommand.cs        |   8 +-
 .../Commands/search/BaseSearchCommand.cs      |   8 +-
 .../Commands/search/LegacySearchCommand.cs    |   8 +-
 .../uninstall/BaseUninstallCommand.cs         |   2 +-
 .../Commands/update/BaseUpdateCommand.cs      |   4 +-
 .../update/LegacyUpdateApplyCommand.cs        |   6 +-
 .../update/LegacyUpdateCheckCommand.cs        |   6 +-
 .../Commands/update/UpdateCommand.cs          |   2 +-
 .../NewCommandFactory.cs                      |   2 +-
 .../SymbolExtensions.cs                       |   4 +-
 src/Cli/dotnet-new3/CompleteCommand.cs        |   8 +-
 src/Cli/dotnet-new3/New3CommandFactory.cs     |   8 +-
 src/Cli/dotnet-new3/ParserFactory.cs          |   4 +-
 src/Cli/dotnet-new3/Program.cs                |   2 +-
 src/Cli/dotnet/CommonOptions.cs               |  52 +++---
 src/Cli/dotnet/CommonOptionsFactory.cs        |   2 +-
 src/Cli/dotnet/DocumentedCommand.cs           |   2 +-
 src/Cli/dotnet/DotNetCommandFactory.cs        |   2 +-
 .../NugetSearch/NugetSearchApiParameter.cs    |   2 +-
 src/Cli/dotnet/OptionForwardingExtensions.cs  |  20 +--
 src/Cli/dotnet/ParseResultExtensions.cs       |  14 +-
 src/Cli/dotnet/Parser.cs                      |  33 ++--
 src/Cli/dotnet/ParserExtensions.cs            |   2 +-
 .../Telemetry/AllowListToSendFirstArgument.cs |   2 +-
 ...owListToSendVerbSecondVerbFirstArgument.cs |   4 +-
 src/Cli/dotnet/Telemetry/TelemetryFilter.cs   |  10 +-
 .../TopLevelCommandNameAndOptionToLog.cs      |   4 +-
 .../commands/InstallingWorkloadCommand.cs     |  21 +--
 .../commands/dotnet-add/AddCommandParser.cs   |   8 +-
 .../dotnet-add-package/AddPackageParser.cs    |  24 +--
 .../AddProjectToProjectReferenceParser.cs     |  14 +-
 .../dotnet-build/BuildCommandParser.cs        |  28 +--
 .../BuildServerCommandParser.cs               |   6 +-
 .../BuildServerShutdownCommandParser.cs       |  14 +-
 .../dotnet-clean/CleanCommandParser.cs        |  16 +-
 .../dotnet-complete/CompleteCommandParser.cs  |  12 +-
 .../dotnet-complete/ParseCommandParser.cs     |   8 +-
 .../dotnet-format/FormatCommandParser.cs      |   8 +-
 .../commands/dotnet-fsi/FsiCommandParser.cs   |   8 +-
 .../commands/dotnet-help/HelpCommandParser.cs |   8 +-
 ...ternalReportinstallsuccessCommandParser.cs |  10 +-
 .../commands/dotnet-list/ListCommandParser.cs |  12 +-
 .../ListPackageReferencesCommandParser.cs     |  36 ++--
 ...ProjectToProjectReferencesCommandParser.cs |  10 +-
 .../dotnet-msbuild/MSBuildCommandParser.cs    |   8 +-
 .../commands/dotnet-new/NewCommandParser.cs   |  15 +-
 .../dotnet-nuget/NuGetCommandParser.cs        | 160 +++++++++---------
 .../commands/dotnet-pack/PackCommandParser.cs |  24 +--
 .../dotnet-package/PackageCommandParser.cs    |   4 +-
 .../search/PackageSearchCommandParser.cs      |  28 +--
 .../dotnet-publish/PublishCommandParser.cs    |  28 +--
 .../dotnet-remove/RemoveCommandParser.cs      |   8 +-
 .../RemovePackageParser.cs                    |  12 +-
 .../RemoveProjectToProjectReferenceParser.cs  |  12 +-
 .../dotnet-restore/RestoreCommandParser.cs    |  20 +--
 .../dotnet/commands/dotnet-run/RunCommand.cs  |   4 +-
 .../commands/dotnet-run/RunCommandParser.cs   |  32 ++--
 .../commands/dotnet-sdk/SdkCommandParser.cs   |   6 +-
 .../dotnet-sdk/check/SdkCheckCommandParser.cs |   8 +-
 .../commands/dotnet-sln/SlnCommandParser.cs   |   9 +-
 .../commands/dotnet-sln/add/SlnAddParser.cs   |  14 +-
 .../commands/dotnet-sln/list/SlnListParser.cs |  10 +-
 .../migrate/SlnMigrateCommandParser.cs        |   8 +-
 .../dotnet-sln/remove/SlnRemoveParser.cs      |  10 +-
 .../dotnet-store/StoreCommandParser.cs        |  20 +--
 .../dotnet/commands/dotnet-test/Program.cs    |   2 +-
 .../commands/dotnet-test/TestCommandParser.cs |  68 ++++----
 .../dotnet-test/TestingPlatformCommand.cs     |   2 +-
 .../dotnet-test/TestingPlatformOptions.cs     |  24 +--
 .../commands/dotnet-tool/ToolCommandParser.cs |   6 +-
 .../ToolCommandRestorePassThroughOptions.cs   |  10 +-
 .../dotnet-tool/common/ToolAppliedOption.cs   |  12 +-
 .../install/ToolInstallCommandParser.cs       |  42 ++---
 .../ToolInstallGlobalOrToolPathCommand.cs     |   2 +-
 .../dotnet-tool/list/ToolListCommandParser.cs |  19 ++-
 .../restore/ToolRestoreCommandParser.cs       |  16 +-
 .../dotnet-tool/run/ToolRunCommandParser.cs   |  14 +-
 .../search/ToolSearchCommandParser.cs         |  18 +-
 .../uninstall/ToolUninstallCommandParser.cs   |  18 +-
 .../update/ToolUpdateCommandParser.cs         |  14 +-
 .../dotnet-vstest/VSTestCommandParser.cs      |   6 +-
 .../dotnet-workload/WorkloadCommandBase.cs    |   2 +-
 ...dCommandNuGetRestoreActionConfigOptions.cs |  22 +--
 .../dotnet-workload/WorkloadCommandParser.cs  |  11 +-
 .../clean/WorkloadCleanCommandParser.cs       |  10 +-
 .../config/WorkloadConfigCommandParser.cs     |  10 +-
 .../elevate/WorkloadElevateCommandParser.cs   |   8 +-
 .../history/WorkloadHistoryCommandParser.cs   |   8 +-
 .../install/WorkloadInstallCommandParser.cs   |  18 +-
 .../list/WorkloadListCommandParser.cs         |  16 +-
 .../repair/WorkloadRepairCommandParser.cs     |  14 +-
 .../restore/WorkloadRestoreCommandParser.cs   |   8 +-
 .../search/WorkloadSearchCommandParser.cs     |  12 +-
 .../WorkloadSearchVersionsCommandParser.cs    |  16 +-
 .../WorkloadUninstallCommandParser.cs         |  12 +-
 .../update/WorkloadUpdateCommandParser.cs     |  20 +--
 .../Program.cs                                |  64 +++----
 .../Microsoft.DotNet.GenAPI.Tool/Program.cs   |  20 +--
 .../containerize/ContainerizeCommand.cs       |  54 +++---
 src/StaticWebAssetsSdk/Tool/Program.cs        |  10 +-
 .../ParserTests/InstallTests.cs               |   2 +-
 .../InstantiateTests.Subcommand.cs            |  14 +-
 .../ParserTests/InstantiateTests.cs           |  28 +--
 .../ParserTests/ListTests.cs                  |   2 +-
 .../ParserTests/MiscTests.cs                  |  10 +-
 .../ParserTests/SearchTests.cs                |   6 +-
 .../TabCompletionTests.Approval.cs            |  20 +--
 .../ParserTests/TabCompletionTests.cs         |  12 +-
 .../ParserTests/UninstallTests.cs             |   2 +-
 .../ParserTests/UpdateTests.cs                |   2 +-
 .../ListTemplateResolverTests.cs              |   2 +-
 .../GivenDotnetBuildBuildsCsproj.cs           |   4 +-
 .../BuildRelatedCommandParserTests.cs         |   4 +-
 .../MSBuildArgumentCommandLineParserTests.cs  |   2 +-
 151 files changed, 1041 insertions(+), 1032 deletions(-)

diff --git a/src/BlazorWasmSdk/Tool/Program.cs b/src/BlazorWasmSdk/Tool/Program.cs
index c4f497eef7e3..7b9d504df849 100644
--- a/src/BlazorWasmSdk/Tool/Program.cs
+++ b/src/BlazorWasmSdk/Tool/Program.cs
@@ -12,20 +12,20 @@ internal static class Program
     {
         public static int Main(string[] args)
         {
-            CliRootCommand rootCommand = new();
-            CliCommand brotli = new("brotli");
+            RootCommand rootCommand = new();
+            Command brotli = new("brotli");
 
-            CliOption<CompressionLevel> compressionLevelOption = new("-c")
+            Option<CompressionLevel> compressionLevelOption = new("-c")
             {
                 DefaultValueFactory = _ => CompressionLevel.SmallestSize,
                 Description = "System.IO.Compression.CompressionLevel for the Brotli compression algorithm.",
             };
-            CliOption<List<string>> sourcesOption = new("-s")
+            Option<List<string>> sourcesOption = new("-s")
             {
                 Description = "A list of files to compress.",
                 AllowMultipleArgumentsPerToken = false
             };
-            CliOption<List<string>> outputsOption = new("-o")
+            Option<List<string>> outputsOption = new("-o")
             {
                 Description = "The filenames to output the compressed file to.",
                 AllowMultipleArgumentsPerToken = false
diff --git a/src/BuiltInTools/dotnet-format/Commands/FormatAnalyzersCommand.cs b/src/BuiltInTools/dotnet-format/Commands/FormatAnalyzersCommand.cs
index 3a601096addf..fb60d6a922e4 100644
--- a/src/BuiltInTools/dotnet-format/Commands/FormatAnalyzersCommand.cs
+++ b/src/BuiltInTools/dotnet-format/Commands/FormatAnalyzersCommand.cs
@@ -13,9 +13,9 @@ internal static class FormatAnalyzersCommand
     {
         private static readonly FormatAnalyzersHandler s_analyzerHandler = new();
 
-        internal static CliCommand GetCommand()
+        internal static Command GetCommand()
         {
-            var command = new CliCommand("analyzers", Resources.Run_3rd_party_analyzers__and_apply_fixes)
+            var command = new Command("analyzers", Resources.Run_3rd_party_analyzers__and_apply_fixes)
             {
                 DiagnosticsOption,
                 ExcludeDiagnosticsOption,
@@ -26,7 +26,7 @@ internal static CliCommand GetCommand()
             return command;
         }
 
-        private class FormatAnalyzersHandler : AsynchronousCliAction
+        private class FormatAnalyzersHandler : AsynchronousCommandLineAction
         {
             public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
             {
diff --git a/src/BuiltInTools/dotnet-format/Commands/FormatCommandCommon.cs b/src/BuiltInTools/dotnet-format/Commands/FormatCommandCommon.cs
index a801de15dfbf..f889bc74d5f1 100644
--- a/src/BuiltInTools/dotnet-format/Commands/FormatCommandCommon.cs
+++ b/src/BuiltInTools/dotnet-format/Commands/FormatCommandCommon.cs
@@ -19,67 +19,67 @@ internal static class FormatCommandCommon
         private static string[] VerbosityLevels => new[] { "q", "quiet", "m", "minimal", "n", "normal", "d", "detailed", "diag", "diagnostic" };
         private static string[] SeverityLevels => new[] { "info", "warn", "error" };
 
-        public static readonly CliArgument<string> SlnOrProjectArgument = new CliArgument<string>(Resources.SolutionOrProjectArgumentName)
+        public static readonly Argument<string> SlnOrProjectArgument = new Argument<string>(Resources.SolutionOrProjectArgumentName)
         {
             Description = Resources.SolutionOrProjectArgumentDescription,
             Arity = ArgumentArity.ZeroOrOne
         }.DefaultToCurrentDirectory();
 
-        internal static readonly CliOption<bool> FolderOption = new("--folder")
+        internal static readonly Option<bool> FolderOption = new("--folder")
         {
             Description = Resources.Whether_to_treat_the_workspace_argument_as_a_simple_folder_of_files,
         };
-        internal static readonly CliOption<bool> NoRestoreOption = new("--no-restore")
+        internal static readonly Option<bool> NoRestoreOption = new("--no-restore")
         {
             Description = Resources.Doesnt_execute_an_implicit_restore_before_formatting,
         };
-        internal static readonly CliOption<bool> VerifyNoChanges = new("--verify-no-changes")
+        internal static readonly Option<bool> VerifyNoChanges = new("--verify-no-changes")
         {
             Description = Resources.Verify_no_formatting_changes_would_be_performed_Terminates_with_a_non_zero_exit_code_if_any_files_would_have_been_formatted,
         };
-        internal static readonly CliOption<string[]> DiagnosticsOption = new("--diagnostics")
+        internal static readonly Option<string[]> DiagnosticsOption = new("--diagnostics")
         {
             AllowMultipleArgumentsPerToken = true,
             DefaultValueFactory = _ => Array.Empty<string>(),
             Description = Resources.A_space_separated_list_of_diagnostic_ids_to_use_as_a_filter_when_fixing_code_style_or_3rd_party_issues,
         };
-        internal static readonly CliOption<string[]> ExcludeDiagnosticsOption = new("--exclude-diagnostics")
+        internal static readonly Option<string[]> ExcludeDiagnosticsOption = new("--exclude-diagnostics")
         {
             AllowMultipleArgumentsPerToken = true,
             DefaultValueFactory = _ => Array.Empty<string>(),
             Description = Resources.A_space_separated_list_of_diagnostic_ids_to_ignore_when_fixing_code_style_or_3rd_party_issues,
         };
-        internal static readonly CliOption<string> SeverityOption = new CliOption<string>("--severity")
+        internal static readonly Option<string> SeverityOption = new Option<string>("--severity")
         {
             Description = Resources.The_severity_of_diagnostics_to_fix_Allowed_values_are_info_warn_and_error,
         };
-        internal static readonly CliOption<string[]> IncludeOption = new("--include")
+        internal static readonly Option<string[]> IncludeOption = new("--include")
         {
             AllowMultipleArgumentsPerToken = true,
             DefaultValueFactory = _ => Array.Empty<string>(),
             Description = Resources.A_list_of_relative_file_or_folder_paths_to_include_in_formatting_All_files_are_formatted_if_empty,
         };
-        internal static readonly CliOption<string[]> ExcludeOption = new("--exclude")
+        internal static readonly Option<string[]> ExcludeOption = new("--exclude")
         {
             AllowMultipleArgumentsPerToken = true,
             DefaultValueFactory = _ => Array.Empty<string>(),
             Description = Resources.A_list_of_relative_file_or_folder_paths_to_exclude_from_formatting,
         };
-        internal static readonly CliOption<bool> IncludeGeneratedOption = new("--include-generated")
+        internal static readonly Option<bool> IncludeGeneratedOption = new("--include-generated")
         {
             Description = Resources.Format_files_generated_by_the_SDK,
         };
-        internal static readonly CliOption<string> VerbosityOption = new CliOption<string>("--verbosity", "-v")
+        internal static readonly Option<string> VerbosityOption = new Option<string>("--verbosity", "-v")
         {
             Description = Resources.Set_the_verbosity_level_Allowed_values_are_quiet_minimal_normal_detailed_and_diagnostic,
         };
-        internal static readonly CliOption<string> BinarylogOption = new CliOption<string>("--binarylog")
+        internal static readonly Option<string> BinarylogOption = new Option<string>("--binarylog")
         {
             HelpName = "binary-log-path",
             Arity = ArgumentArity.ZeroOrOne,
             Description = Resources.Log_all_project_or_solution_load_information_to_a_binary_log_file,
         };
-        internal static readonly CliOption<string> ReportOption = new CliOption<string>("--report")
+        internal static readonly Option<string> ReportOption = new Option<string>("--report")
         {
             HelpName = "report-path",
             Arity = ArgumentArity.ZeroOrOne,
@@ -118,7 +118,7 @@ internal static async Task<int> FormatAsync(FormatOptions formatOptions, ILogger
             return formatResult.GetExitCode(formatOptions.ChangesAreErrors);
         }
 
-        public static void AddCommonOptions(this CliCommand command)
+        public static void AddCommonOptions(this Command command)
         {
             command.Arguments.Add(SlnOrProjectArgument);
             command.Options.Add(NoRestoreOption);
@@ -131,7 +131,7 @@ public static void AddCommonOptions(this CliCommand command)
             command.Options.Add(ReportOption);
         }
 
-        public static CliArgument<string> DefaultToCurrentDirectory(this CliArgument<string> arg)
+        public static Argument<string> DefaultToCurrentDirectory(this Argument<string> arg)
         {
             arg.DefaultValueFactory = _ => EnsureTrailingSlash(Directory.GetCurrentDirectory());
             return arg;
diff --git a/src/BuiltInTools/dotnet-format/Commands/FormatStyleCommand.cs b/src/BuiltInTools/dotnet-format/Commands/FormatStyleCommand.cs
index d7aaa6519774..9a3575dd0e78 100644
--- a/src/BuiltInTools/dotnet-format/Commands/FormatStyleCommand.cs
+++ b/src/BuiltInTools/dotnet-format/Commands/FormatStyleCommand.cs
@@ -13,9 +13,9 @@ internal static class FormatStyleCommand
     {
         private static readonly FormatStyleHandler s_styleHandler = new();
 
-        internal static CliCommand GetCommand()
+        internal static Command GetCommand()
         {
-            var command = new CliCommand("style", Resources.Run_code_style_analyzers_and_apply_fixes)
+            var command = new Command("style", Resources.Run_code_style_analyzers_and_apply_fixes)
             {
                 DiagnosticsOption,
                 ExcludeDiagnosticsOption,
@@ -26,7 +26,7 @@ internal static CliCommand GetCommand()
             return command;
         }
 
-        private class FormatStyleHandler : AsynchronousCliAction
+        private class FormatStyleHandler : AsynchronousCommandLineAction
         {
             public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
             {
diff --git a/src/BuiltInTools/dotnet-format/Commands/FormatWhitespaceCommand.cs b/src/BuiltInTools/dotnet-format/Commands/FormatWhitespaceCommand.cs
index 3c28fe4c5474..c6fd6742c1b2 100644
--- a/src/BuiltInTools/dotnet-format/Commands/FormatWhitespaceCommand.cs
+++ b/src/BuiltInTools/dotnet-format/Commands/FormatWhitespaceCommand.cs
@@ -28,9 +28,9 @@ internal delegate Task<int> Handler(
 
         private static readonly FormatWhitespaceHandler s_formattingHandler = new();
 
-        internal static CliCommand GetCommand()
+        internal static Command GetCommand()
         {
-            var command = new CliCommand("whitespace", Resources.Run_whitespace_formatting)
+            var command = new Command("whitespace", Resources.Run_whitespace_formatting)
             {
                 FolderOption
             };
@@ -61,7 +61,7 @@ internal static void EnsureFolderNotSpecifiedWhenLoggingBinlog(CommandResult sym
             }
         }
 
-        private class FormatWhitespaceHandler : AsynchronousCliAction
+        private class FormatWhitespaceHandler : AsynchronousCommandLineAction
         {
             public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
             {
diff --git a/src/BuiltInTools/dotnet-format/Commands/RootFormatCommand.cs b/src/BuiltInTools/dotnet-format/Commands/RootFormatCommand.cs
index 55947beed4ad..6b87ddd5a3c5 100644
--- a/src/BuiltInTools/dotnet-format/Commands/RootFormatCommand.cs
+++ b/src/BuiltInTools/dotnet-format/Commands/RootFormatCommand.cs
@@ -13,9 +13,9 @@ internal static class RootFormatCommand
     {
         private static readonly FormatCommandDefaultHandler s_formatCommandHandler = new();
 
-        public static CliRootCommand GetCommand()
+        public static RootCommand GetCommand()
         {
-            var formatCommand = new CliRootCommand(Resources.Formats_code_to_match_editorconfig_settings)
+            var formatCommand = new RootCommand(Resources.Formats_code_to_match_editorconfig_settings)
             {
                 FormatWhitespaceCommand.GetCommand(),
                 FormatStyleCommand.GetCommand(),
@@ -29,7 +29,7 @@ public static CliRootCommand GetCommand()
             return formatCommand;
         }
 
-        private class FormatCommandDefaultHandler : AsynchronousCliAction
+        private class FormatCommandDefaultHandler : AsynchronousCommandLineAction
         {
             public override async Task<int> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
             {
diff --git a/src/BuiltInTools/dotnet-watch/CommandLineOptions.cs b/src/BuiltInTools/dotnet-watch/CommandLineOptions.cs
index 7441aaaa0496..6af8e81b7899 100644
--- a/src/BuiltInTools/dotnet-watch/CommandLineOptions.cs
+++ b/src/BuiltInTools/dotnet-watch/CommandLineOptions.cs
@@ -36,11 +36,11 @@ internal sealed class CommandLineOptions
     {
         // dotnet watch specific options:
 
-        var quietOption = new CliOption<bool>("--quiet", "-q") { Description = Resources.Help_Quiet };
-        var verboseOption = new CliOption<bool>("--verbose") { Description = Resources.Help_Verbose };
-        var listOption = new CliOption<bool>("--list") { Description = Resources.Help_List };
-        var noHotReloadOption = new CliOption<bool>("--no-hot-reload") { Description = Resources.Help_NoHotReload };
-        var nonInteractiveOption = new CliOption<bool>("--non-interactive") { Description = Resources.Help_NonInteractive };
+        var quietOption = new Option<bool>("--quiet", "-q") { Description = Resources.Help_Quiet };
+        var verboseOption = new Option<bool>("--verbose") { Description = Resources.Help_Verbose };
+        var listOption = new Option<bool>("--list") { Description = Resources.Help_List };
+        var noHotReloadOption = new Option<bool>("--no-hot-reload") { Description = Resources.Help_NoHotReload };
+        var nonInteractiveOption = new Option<bool>("--non-interactive") { Description = Resources.Help_NonInteractive };
 
         verboseOption.Validators.Add(v =>
         {
@@ -50,7 +50,7 @@ internal sealed class CommandLineOptions
             }
         });
 
-        CliOption[] watchOptions =
+        Option[] watchOptions =
         [
             quietOption,
             verboseOption,
@@ -61,12 +61,12 @@ internal sealed class CommandLineOptions
 
         // Options we need to know about that are passed through to the subcommand:
 
-        var shortProjectOption = new CliOption<string>("-p") { Hidden = true, Arity = ArgumentArity.ZeroOrOne, AllowMultipleArgumentsPerToken = false };
-        var longProjectOption = new CliOption<string>("--project") { Hidden = true, Arity = ArgumentArity.ZeroOrOne, AllowMultipleArgumentsPerToken = false };
-        var launchProfileOption = new CliOption<string>("--launch-profile", "-lp") { Hidden = true, Arity = ArgumentArity.ZeroOrOne, AllowMultipleArgumentsPerToken = false };
-        var noLaunchProfileOption = new CliOption<bool>("--no-launch-profile") { Hidden = true };
+        var shortProjectOption = new Option<string>("-p") { Hidden = true, Arity = ArgumentArity.ZeroOrOne, AllowMultipleArgumentsPerToken = false };
+        var longProjectOption = new Option<string>("--project") { Hidden = true, Arity = ArgumentArity.ZeroOrOne, AllowMultipleArgumentsPerToken = false };
+        var launchProfileOption = new Option<string>("--launch-profile", "-lp") { Hidden = true, Arity = ArgumentArity.ZeroOrOne, AllowMultipleArgumentsPerToken = false };
+        var noLaunchProfileOption = new Option<bool>("--no-launch-profile") { Hidden = true };
 
-        var rootCommand = new CliRootCommand(Resources.Help)
+        var rootCommand = new RootCommand(Resources.Help)
         {
             Directives = { new EnvironmentVariablesDirective() },
         };
@@ -92,7 +92,7 @@ internal sealed class CommandLineOptions
         var rootCommandInvoked = false;
         rootCommand.SetAction(parseResult => rootCommandInvoked = true);
 
-        var cliConfig = new CliConfiguration(rootCommand)
+        var cliConfig = new CommandLineConfiguration(rootCommand)
         {
             Output = output,
             Error = output,
@@ -150,7 +150,7 @@ internal sealed class CommandLineOptions
 
         // We assume that forwarded options, if any, are intended for dotnet build.
         var buildArguments = buildOptions.Select(option => ((IForwardedOption)option).GetForwardingFunction()(parseResult)).SelectMany(args => args).ToArray();
-        var targetFrameworkOption = (CliOption<string>?)buildOptions.SingleOrDefault(option => option.Name == "--framework");
+        var targetFrameworkOption = (Option<string>?)buildOptions.SingleOrDefault(option => option.Name == "--framework");
 
         return new()
         {
@@ -176,8 +176,8 @@ internal sealed class CommandLineOptions
 
     private static IReadOnlyList<string> GetCommandArguments(
         ParseResult parseResult,
-        IReadOnlyList<CliOption> watchOptions,
-        CliCommand? explicitCommand)
+        IReadOnlyList<Option> watchOptions,
+        Command? explicitCommand)
     {
         var arguments = new List<string>();
 
@@ -246,7 +246,7 @@ private static IReadOnlyList<string> GetCommandArguments(
         return arguments;
     }
 
-    private static CliCommand? TryGetSubcommand(ParseResult parseResult)
+    private static Command? TryGetSubcommand(ParseResult parseResult)
     {
         // Assuming that all tokens after "--" are unmatched:
         var dashDashIndex = IndexOf(parseResult.Tokens, t => t.Value == "--");
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/ChoiceTemplateParameter.cs b/src/Cli/Microsoft.TemplateEngine.Cli/ChoiceTemplateParameter.cs
index 9114f923d212..0246160fc869 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/ChoiceTemplateParameter.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/ChoiceTemplateParameter.cs
@@ -68,11 +68,11 @@ internal ChoiceTemplateParameter(ChoiceTemplateParameter choiceTemplateParameter
             };
         }
 
-        protected override CliOption GetBaseOption(IReadOnlySet<string> aliases)
+        protected override Option GetBaseOption(IReadOnlySet<string> aliases)
         {
             string name = GetName(aliases);
 
-            CliOption<string> option = new(name)
+            Option<string> option = new(name)
             {
                 CustomParser = result => GetParseChoiceArgument(this)(result),
                 Arity = new ArgumentArity(DefaultIfOptionWithoutValue == null ? 1 : 0, AllowMultipleValues ? _choices.Count : 1),
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/CliTemplateParameter.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CliTemplateParameter.cs
index c528f549c72c..59aa48581d4f 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/CliTemplateParameter.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/CliTemplateParameter.cs
@@ -134,12 +134,12 @@ internal CliTemplateParameter(CliTemplateParameter other)
         protected bool AllowMultipleValues { get; private init; }
 
         /// <summary>
-        /// Creates <see cref="CliOption"/> for template parameter.
+        /// Creates <see cref="Option"/> for template parameter.
         /// </summary>
         /// <param name="aliases">aliases to be used for option.</param>
-        internal CliOption GetOption(IReadOnlySet<string> aliases)
+        internal Option GetOption(IReadOnlySet<string> aliases)
         {
-            CliOption option = GetBaseOption(aliases);
+            Option option = GetBaseOption(aliases);
             option.Hidden = IsHidden;
 
             //if parameter is required, the default value is ignored.
@@ -151,13 +151,13 @@ internal CliOption GetOption(IReadOnlySet<string> aliases)
                 {
                     switch (option)
                     {
-                        case CliOption<string> stringOption:
+                        case Option<string> stringOption:
                             stringOption.DefaultValueFactory = (_) => DefaultValue;
                             break;
-                        case CliOption<bool> booleanOption:
+                        case Option<bool> booleanOption:
                             booleanOption.DefaultValueFactory = (_) => bool.Parse(DefaultValue);
                             break;
-                        case CliOption<long> integerOption:
+                        case Option<long> integerOption:
                             if (Type == ParameterType.Hex)
                             {
                                 integerOption.DefaultValueFactory = (_) => Convert.ToInt64(DefaultValue, 16);
@@ -167,10 +167,10 @@ internal CliOption GetOption(IReadOnlySet<string> aliases)
                                 integerOption.DefaultValueFactory = (_) => long.Parse(DefaultValue);
                             }
                             break;
-                        case CliOption<float> floatOption:
+                        case Option<float> floatOption:
                             floatOption.DefaultValueFactory = (_) => float.Parse(DefaultValue);
                             break;
-                        case CliOption<double> doubleOption:
+                        case Option<double> doubleOption:
                             doubleOption.DefaultValueFactory = (_) => double.Parse(DefaultValue);
                             break;
                         default:
@@ -203,31 +203,31 @@ internal CliOption GetOption(IReadOnlySet<string> aliases)
             };
         }
 
-        protected virtual CliOption GetBaseOption(IReadOnlySet<string> aliases)
+        protected virtual Option GetBaseOption(IReadOnlySet<string> aliases)
         {
             string name = GetName(aliases);
-            CliOption cliOption = Type switch
+            Option cliOption = Type switch
             {
-                ParameterType.Boolean => new CliOption<bool>(name)
+                ParameterType.Boolean => new Option<bool>(name)
                 {
                     Arity = new ArgumentArity(0, 1)
                 },
-                ParameterType.Integer => new CliOption<long>(name)
+                ParameterType.Integer => new Option<long>(name)
                 {
                     CustomParser = result => GetParseArgument(this, ConvertValueToInt)(result),
                     Arity = new ArgumentArity(string.IsNullOrWhiteSpace(DefaultIfOptionWithoutValue) ? 1 : 0, 1)
                 },
-                ParameterType.String => new CliOption<string>(name)
+                ParameterType.String => new Option<string>(name)
                 {
                     CustomParser = result => GetParseArgument(this, ConvertValueToString)(result),
                     Arity = new ArgumentArity(DefaultIfOptionWithoutValue == null ? 1 : 0, 1)
                 },
-                ParameterType.Float => new CliOption<double>(name)
+                ParameterType.Float => new Option<double>(name)
                 {
                     CustomParser = result => GetParseArgument(this, ConvertValueToFloat)(result),
                     Arity = new ArgumentArity(string.IsNullOrWhiteSpace(DefaultIfOptionWithoutValue) ? 1 : 0, 1)
                 },
-                ParameterType.Hex => new CliOption<long>(name)
+                ParameterType.Hex => new Option<long>(name)
                 {
                     CustomParser = result => GetParseArgument(this, ConvertValueToHex)(result),
                     Arity = new ArgumentArity(string.IsNullOrWhiteSpace(DefaultIfOptionWithoutValue) ? 1 : 0, 1)
@@ -271,7 +271,7 @@ static int GetPrefixLength(string alias)
             }
         }
 
-        protected void AddAliases(CliOption option, IReadOnlySet<string> aliases)
+        protected void AddAliases(Option option, IReadOnlySet<string> aliases)
         {
             foreach (string alias in aliases)
             {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
index cd0107dc0b95..1e68bed11b29 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
@@ -12,10 +12,11 @@
 using Microsoft.TemplateEngine.Edge;
 using Microsoft.TemplateEngine.Edge.Settings;
 using Microsoft.TemplateEngine.Utils;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal abstract class BaseCommand : CliCommand
+    internal abstract class BaseCommand : Command
     {
         private readonly Func<ParseResult, ITemplateEngineHost> _hostBuilder;
 
@@ -96,9 +97,9 @@ protected internal static async Task CheckTemplatesWithSubCommandName(
             Reporter.Output.WriteLine();
         }
 
-        protected static void PrintDeprecationMessage<TDepr, TNew>(ParseResult parseResult, CliOption? additionalOption = null)
-            where TDepr : CliCommand
-            where TNew : CliCommand
+        protected static void PrintDeprecationMessage<TDepr, TNew>(ParseResult parseResult, Option? additionalOption = null)
+            where TDepr : Command
+            where TNew : Command
         {
             var newCommandExample = Example.For<TNew>(parseResult);
             if (additionalOption != null)
@@ -120,17 +121,17 @@ protected static void PrintDeprecationMessage<TDepr, TNew>(ParseResult parseResu
 
         protected abstract TArgs ParseContext(ParseResult parseResult);
 
-        protected virtual CliOption GetFilterOption(FilterOptionDefinition def)
+        protected virtual Option GetFilterOption(FilterOptionDefinition def)
         {
             return def.OptionFactory();
         }
 
-        protected IReadOnlyDictionary<FilterOptionDefinition, CliOption> SetupFilterOptions(IReadOnlyList<FilterOptionDefinition> filtersToSetup)
+        protected IReadOnlyDictionary<FilterOptionDefinition, Option> SetupFilterOptions(IReadOnlyList<FilterOptionDefinition> filtersToSetup)
         {
-            Dictionary<FilterOptionDefinition, CliOption> options = new();
+            Dictionary<FilterOptionDefinition, Option> options = new();
             foreach (FilterOptionDefinition filterDef in filtersToSetup)
             {
-                CliOption newOption = GetFilterOption(filterDef);
+                Option newOption = GetFilterOption(filterDef);
                 Options.Add(newOption);
                 options[filterDef] = newOption;
             }
@@ -220,7 +221,7 @@ private static void HandleDebugShowConfig(TArgs args, IEngineEnvironmentSettings
             Reporter.Output.WriteLine();
         }
 
-        private sealed class CommandAction : AsynchronousCliAction
+        private sealed class CommandAction : AsynchronousCommandLineAction
         {
             private readonly BaseCommand<TArgs> _command;
 
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/CommandLineUtils.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/CommandLineUtils.cs
index 82315d97fdb1..150fb896a520 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/CommandLineUtils.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/CommandLineUtils.cs
@@ -9,7 +9,7 @@ internal class CommandLineUtils
     {
         // This code is from System.CommandLine, HelpBuilder class.
         // Ideally those methods are exposed, we may switch to use them.
-        internal static string FormatArgumentUsage(IReadOnlyList<CliArgument> arguments)
+        internal static string FormatArgumentUsage(IReadOnlyList<Argument> arguments)
         {
             var sb = new StringBuilder();
             var end = default(Stack<char>);
@@ -56,20 +56,20 @@ internal static string FormatArgumentUsage(IReadOnlyList<CliArgument> arguments)
             }
 
             return sb.ToString();
-            bool IsMultiParented(CliArgument argument) =>
+            bool IsMultiParented(Argument argument) =>
                 argument.Parents.Count() > 1;
 
-            bool IsOptional(CliArgument argument) =>
+            bool IsOptional(Argument argument) =>
                 IsMultiParented(argument) ||
                 argument.Arity.MinimumNumberOfValues == 0;
         }
 
-        internal static string FormatArgumentUsage(CliArgument argument) => FormatArgumentUsage(new[] { argument });
+        internal static string FormatArgumentUsage(Argument argument) => FormatArgumentUsage(new[] { argument });
 
-        internal static string FormatArgumentUsage(CliOption option) => FormatArgumentUsage(new[] { option });
+        internal static string FormatArgumentUsage(Option option) => FormatArgumentUsage(new[] { option });
 
         // separate instance as Option.Argument is internal.
-        internal static string FormatArgumentUsage(IReadOnlyList<CliOption> options)
+        internal static string FormatArgumentUsage(IReadOnlyList<Option> options)
         {
             var sb = new StringBuilder();
             var end = default(Stack<char>);
@@ -116,10 +116,10 @@ internal static string FormatArgumentUsage(IReadOnlyList<CliOption> options)
             }
 
             return sb.ToString();
-            bool IsMultiParented(CliOption option) =>
+            bool IsMultiParented(Option option) =>
                 option.Parents.Count() > 1;
 
-            bool IsOptional(CliOption option) =>
+            bool IsOptional(Option option) =>
                 IsMultiParented(option) ||
                 option.Arity.MinimumNumberOfValues == 0;
         }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Example.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Example.cs
index a1a273cf7603..9ee48e0ccdd0 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Example.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Example.cs
@@ -9,9 +9,9 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     internal class Example
     {
         private List<string> _commandParts = new();
-        private CliCommand _currentCommand;
+        private Command _currentCommand;
 
-        private Example(CliCommand currentCommand, params string[] commandParts)
+        private Example(Command currentCommand, params string[] commandParts)
         {
             _commandParts.AddRange(commandParts);
             _currentCommand = currentCommand;
@@ -24,7 +24,7 @@ public override string ToString()
             return string.Join(" ", _commandParts);
         }
 
-        internal static Example For<T>(ParseResult parseResult) where T : CliCommand
+        internal static Example For<T>(ParseResult parseResult) where T : Command
         {
             var commandResult = parseResult.CommandResult;
 
@@ -47,13 +47,13 @@ internal static Example For<T>(ParseResult parseResult) where T : CliCommand
             }
 
             // if the command is not found in parents of command result, try to search it in the whole command tree
-            CliCommand siblingCommand = SearchForSiblingCommand<T>(parseResult.CommandResult.Command);
+            Command siblingCommand = SearchForSiblingCommand<T>(parseResult.CommandResult.Command);
             List<string> parentCommands2 = new();
-            CliCommand? nextCommand = siblingCommand;
+            Command? nextCommand = siblingCommand;
             while (nextCommand != null)
             {
                 parentCommands2.Add(nextCommand.Name);
-                nextCommand = nextCommand.Parents.OfType<CliCommand>().FirstOrDefault();
+                nextCommand = nextCommand.Parents.OfType<Command>().FirstOrDefault();
             }
             parentCommands2.Reverse();
             return new Example(siblingCommand, parentCommands2.ToArray());
@@ -66,7 +66,7 @@ internal static Example FromExistingTokens(ParseResult parseResult)
             return new Example(parseResult.CommandResult.Command, commandParts.ToArray());
         }
 
-        internal Example WithOption(CliOption option, params string[] args)
+        internal Example WithOption(Option option, params string[] args)
         {
             if (!_currentCommand.Options.Contains(option) && !_currentCommand.Options.Any(o => o.Name == option.Name))
             {
@@ -88,7 +88,7 @@ internal Example WithOption(CliOption option, params string[] args)
             return this;
         }
 
-        internal Example WithArgument(CliArgument argument, params string[] args)
+        internal Example WithArgument(Argument argument, params string[] args)
         {
             if (!_currentCommand.Arguments.Contains(argument))
             {
@@ -104,7 +104,7 @@ internal Example WithArgument(CliArgument argument, params string[] args)
             return this;
         }
 
-        internal Example WithSubcommand(CliCommand command)
+        internal Example WithSubcommand(Command command)
         {
             if (!_currentCommand.Subcommands.Contains(command))
             {
@@ -118,7 +118,7 @@ internal Example WithSubcommand(CliCommand command)
 
         internal Example WithSubcommand(string token)
         {
-            CliCommand? commandToUse = _currentCommand.Subcommands.FirstOrDefault(c => c.Name.Equals(token) || c.Aliases.Contains(token));
+            Command? commandToUse = _currentCommand.Subcommands.FirstOrDefault(c => c.Name.Equals(token) || c.Aliases.Contains(token));
 
             if (commandToUse is null)
             {
@@ -130,7 +130,7 @@ internal Example WithSubcommand(string token)
             return this;
         }
 
-        internal Example WithSubcommand<T>() where T : CliCommand
+        internal Example WithSubcommand<T>() where T : Command
         {
             if (!_currentCommand.Subcommands.Any(c => c is T))
             {
@@ -148,22 +148,22 @@ internal Example WithHelpOption()
             return this;
         }
 
-        private static T SearchForSiblingCommand<T>(CliCommand currentCommand) where T : CliCommand
+        private static T SearchForSiblingCommand<T>(Command currentCommand) where T : Command
         {
-            CliCommand? next = currentCommand;
-            CliCommand root = currentCommand;
+            Command? next = currentCommand;
+            Command root = currentCommand;
 
             while (next != null)
             {
                 root = next;
-                next = next?.Parents.OfType<CliCommand>().FirstOrDefault();
+                next = next?.Parents.OfType<Command>().FirstOrDefault();
             }
 
-            Queue<CliCommand> probes = new();
+            Queue<Command> probes = new();
             probes.Enqueue(root);
             while (probes.Count > 0)
             {
-                CliCommand current = probes.Dequeue();
+                Command current = probes.Dequeue();
                 if (current is T typedCommand)
                 {
                     return typedCommand;
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Extensions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Extensions.cs
index 3537635e573f..c535d2a218e7 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Extensions.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/Extensions.cs
@@ -12,7 +12,7 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal static class Extensions
     {
-        internal static string? GetValueForOptionOrNull(this ParseResult parseResult, CliOption option)
+        internal static string? GetValueForOptionOrNull(this ParseResult parseResult, Option option)
         {
             OptionResult? result = parseResult.GetResult(option);
             if (result == null)
@@ -25,21 +25,21 @@ internal static class Extensions
         /// <summary>
         /// Checks if <paramref name="parseResult"/> contains an error for <paramref name="option"/>.
         /// </summary>
-        internal static bool HasErrorFor(this ParseResult parseResult, CliOption option, [NotNullWhen(true)] out ParseError? error)
+        internal static bool HasErrorFor(this ParseResult parseResult, Option option, [NotNullWhen(true)] out ParseError? error)
         {
             error = parseResult.Errors.FirstOrDefault(e => IsOptionResult(e.SymbolResult, option)
                 || IsOptionResult(e.SymbolResult?.Parent, option));
 
             return error is not null;
 
-            static bool IsOptionResult(SymbolResult? symbolResult, CliOption option)
+            static bool IsOptionResult(SymbolResult? symbolResult, Option option)
                 => symbolResult is OptionResult optionResult && optionResult.Option == option;
         }
 
         /// <summary>
-        /// Case insensitive version for <see cref="System.CommandLine.CliOption{TOption}.AcceptOnlyFromAmong(string[])"/>.
+        /// Case insensitive version for <see cref="System.CommandLine.Option{TOption}.AcceptOnlyFromAmong(string[])"/>.
         /// </summary>
-        internal static void FromAmongCaseInsensitive(this CliOption<string> option, string[]? allowedValues = null, string? allowedHiddenValue = null)
+        internal static void FromAmongCaseInsensitive(this Option<string> option, string[]? allowedValues = null, string? allowedHiddenValue = null)
         {
             allowedValues ??= Array.Empty<string>();
             option.Validators.Add(optionResult => ValidateAllowedValues(optionResult, allowedValues, allowedHiddenValue));
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
index cea685b5ac1b..ef5725f870cf 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
@@ -16,7 +16,7 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     /// </summary>
     internal class FilterOptionDefinition
     {
-        internal FilterOptionDefinition(Func<CliOption> optionFactory)
+        internal FilterOptionDefinition(Func<Option> optionFactory)
         {
             OptionFactory = optionFactory ?? throw new ArgumentNullException(nameof(optionFactory));
         }
@@ -64,7 +64,7 @@ internal FilterOptionDefinition(Func<CliOption> optionFactory)
         /// <summary>
         /// A predicate that creates instance of option.
         /// </summary>
-        internal Func<CliOption> OptionFactory { get; }
+        internal Func<Option> OptionFactory { get; }
 
         private static Func<ITemplatePackageInfo, bool> PackageMatchFilter(string? packageArg)
         {
@@ -85,7 +85,7 @@ private static Func<ITemplatePackageInfo, bool> PackageMatchFilter(string? packa
     internal class TemplateFilterOptionDefinition : FilterOptionDefinition
     {
         internal TemplateFilterOptionDefinition(
-            Func<CliOption> optionFactory,
+            Func<Option> optionFactory,
             Func<string?, Func<ITemplateInfo, MatchInfo?>> matchFilter,
             Func<TemplateResolutionResult, bool> mismatchCriteria,
             string matchInfoName) : base(optionFactory)
@@ -121,7 +121,7 @@ internal TemplateFilterOptionDefinition(
     internal class PackageFilterOptionDefinition : FilterOptionDefinition
     {
         internal PackageFilterOptionDefinition(
-            Func<CliOption> optionFactory,
+            Func<Option> optionFactory,
             Func<string?, Func<ITemplatePackageInfo, bool>> matchFilter) : base(optionFactory)
         {
             PackageMatchFilter = matchFilter ?? throw new ArgumentNullException(nameof(matchFilter));
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
index 4c4e5278a4aa..09b5e51ca77b 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
@@ -31,7 +31,7 @@ protected GlobalArgs(GlobalArgs args) : this(args.Command, args.ParseResult) { }
 
         public ParseResult ParseResult { get; }
 
-        CliCommand ICommandArgs.Command => Command;
+        Command ICommandArgs.Command => Command;
 
         internal bool DebugAttach { get; private set; }
 
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandArgs.cs
index a807e6617b43..6d60b750a095 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandArgs.cs
@@ -14,9 +14,9 @@ internal interface ICommandArgs
         internal NewCommand RootCommand { get; }
 
         /// <summary>
-        /// Gets the executing <see cref="System.CommandLine.CliCommand"/>.
+        /// Gets the executing <see cref="System.CommandLine.Command"/>.
         /// </summary>
-        internal CliCommand Command { get; }
+        internal Command Command { get; }
 
         /// <summary>
         /// Gets the <see cref="System.CommandLine.ParseResult"/> for the command to be executed.
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandDocument.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandDocument.cs
index 2af15b6d0c20..dc11c8327f36 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandDocument.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICommandDocument.cs
@@ -6,7 +6,7 @@
 namespace Microsoft.TemplateEngine.Cli.Commands;
 
 /// <summary>
-/// If a <see cref="CliCommand"/> implements this interface, it can open
+/// If a <see cref="Command"/> implements this interface, it can open
 /// its documentation page online.
 /// </summary>
 public interface ICommandDocument
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICustomHelp.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICustomHelp.cs
index db32c6c644a3..cbecaba9149b 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICustomHelp.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ICustomHelp.cs
@@ -7,7 +7,7 @@
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
     /// <summary>
-    /// If <see cref="CliCommand"/> implements this interface, it can create custom help
+    /// If <see cref="Command"/> implements this interface, it can create custom help
     /// that should be used when building the parser.
     /// </summary>
     public interface ICustomHelp
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs
index 4f5788fecd48..a8a824e51dfd 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/IFilterableCommand.cs
@@ -7,6 +7,6 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal interface IFilterableCommand
     {
-        IReadOnlyDictionary<FilterOptionDefinition, CliOption> Filters { get; }
+        IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; }
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ITabularOutputCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ITabularOutputCommand.cs
index 10609361542a..96e4057d8cac 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ITabularOutputCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ITabularOutputCommand.cs
@@ -7,9 +7,9 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal interface ITabularOutputCommand
     {
-        internal CliOption<bool> ColumnsAllOption { get; }
+        internal Option<bool> ColumnsAllOption { get; }
 
-        internal CliOption<string[]> ColumnsOption { get; }
+        internal Option<string[]> ColumnsOption { get; }
     }
 
     internal interface ITabularOutputArgs
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
index 315bb73e4c1d..4470c1cd82e8 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
@@ -19,7 +19,7 @@ internal partial class NewCommand : BaseCommand<NewCommandArgs>
             FilterOptionDefinition.PackageFilter
         };
 
-        internal IEnumerable<CliOption> LegacyOptions
+        internal IEnumerable<Option> LegacyOptions
         {
             get
             {
@@ -27,29 +27,29 @@ internal IEnumerable<CliOption> LegacyOptions
                 yield return AddSourceOption;
                 yield return ColumnsAllOption;
                 yield return ColumnsOption;
-                foreach (CliOption filter in LegacyFilters.Values)
+                foreach (Option filter in LegacyFilters.Values)
                 {
                     yield return filter;
                 }
             }
         }
 
-        internal CliOption<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption().AsHidden();
+        internal Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption().AsHidden();
 
-        internal CliOption<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
+        internal Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
 
-        internal CliOption<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption().AsHidden();
+        internal Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption().AsHidden();
 
-        internal CliOption<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
+        internal Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
 
-        internal IReadOnlyDictionary<FilterOptionDefinition, CliOption> LegacyFilters { get; private set; } = new Dictionary<FilterOptionDefinition, CliOption>();
+        internal IReadOnlyDictionary<FilterOptionDefinition, Option> LegacyFilters { get; private set; } = new Dictionary<FilterOptionDefinition, Option>();
 
-        internal void AddNoLegacyUsageValidators(CliCommand command, params CliSymbol[] except)
+        internal void AddNoLegacyUsageValidators(Command command, params Symbol[] except)
         {
-            IEnumerable<CliOption> optionsToVerify = LegacyFilters.Values.Concat(new CliOption[] { ColumnsAllOption, ColumnsOption, InteractiveOption, AddSourceOption });
-            IEnumerable<CliArgument> argumentsToVerify = new CliArgument[] { ShortNameArgument, RemainingArguments };
+            IEnumerable<Option> optionsToVerify = LegacyFilters.Values.Concat(new Option[] { ColumnsAllOption, ColumnsOption, InteractiveOption, AddSourceOption });
+            IEnumerable<Argument> argumentsToVerify = new Argument[] { ShortNameArgument, RemainingArguments };
 
-            foreach (CliOption option in optionsToVerify)
+            foreach (Option option in optionsToVerify)
             {
                 if (!except.Contains(option))
                 {
@@ -57,7 +57,7 @@ internal void AddNoLegacyUsageValidators(CliCommand command, params CliSymbol[]
                 }
             }
 
-            foreach (CliArgument argument in argumentsToVerify)
+            foreach (Argument argument in argumentsToVerify)
             {
                 if (!except.Contains(argument))
                 {
@@ -76,7 +76,7 @@ internal void ValidateArgumentsAreNotUsed(CommandResult commandResult)
             ValidateArgumentUsage(commandResult, ShortNameArgument, RemainingArguments);
         }
 
-        internal void ValidateOptionUsage(CommandResult commandResult, CliOption option)
+        internal void ValidateOptionUsage(CommandResult commandResult, Option option)
         {
             if (commandResult.Parent is not CommandResult parentResult)
             {
@@ -103,7 +103,7 @@ internal void ValidateOptionUsage(CommandResult commandResult, CliOption option)
             }
         }
 
-        private static void ValidateArgumentUsage(CommandResult commandResult, params CliArgument[] arguments)
+        private static void ValidateArgumentUsage(CommandResult commandResult, params Argument[] arguments)
         {
             if (commandResult.Parent is not CommandResult parentResult)
             {
@@ -111,7 +111,7 @@ private static void ValidateArgumentUsage(CommandResult commandResult, params Cl
             }
 
             List<string> wrongTokens = new();
-            foreach (CliArgument argument in arguments)
+            foreach (Argument argument in arguments)
             {
                 var newCommandArgument = parentResult.Children.OfType<ArgumentResult>().FirstOrDefault(result => result.Argument == argument);
                 if (newCommandArgument == null)
@@ -139,7 +139,7 @@ private void BuildLegacySymbols(Func<ParseResult, ITemplateEngineHost> hostBuild
             Arguments.Add(RemainingArguments);
 
             //legacy options
-            Dictionary<FilterOptionDefinition, CliOption> options = new();
+            Dictionary<FilterOptionDefinition, Option> options = new();
             foreach (var filterDef in LegacyFilterDefinitions)
             {
                 options[filterDef] = filterDef.OptionFactory().AsHidden();
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
index d94840fe09d5..3db21ea63d74 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
@@ -46,63 +46,63 @@ internal NewCommand(
 
         public string DocsLink { get; } = "https://aka.ms/dotnet-new";
 
-        internal static CliOption<string?> DebugCustomSettingsLocationOption { get; } = new("--debug:custom-hive")
+        internal static Option<string?> DebugCustomSettingsLocationOption { get; } = new("--debug:custom-hive")
         {
             Description = SymbolStrings.Option_Debug_CustomSettings,
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliOption<bool> DebugVirtualizeSettingsOption { get; } = new("--debug:ephemeral-hive", "--debug:virtual-hive")
+        internal static Option<bool> DebugVirtualizeSettingsOption { get; } = new("--debug:ephemeral-hive", "--debug:virtual-hive")
         {
             Description = SymbolStrings.Option_Debug_VirtualSettings,
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliOption<bool> DebugAttachOption { get; } = new("--debug:attach")
+        internal static Option<bool> DebugAttachOption { get; } = new("--debug:attach")
         {
             Description = SymbolStrings.Option_Debug_Attach,
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliOption<bool> DebugReinitOption { get; } = new("--debug:reinit")
+        internal static Option<bool> DebugReinitOption { get; } = new("--debug:reinit")
         {
             Description = SymbolStrings.Option_Debug_Reinit,
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliOption<bool> DebugRebuildCacheOption { get; } = new("--debug:rebuild-cache", "--debug:rebuildcache")
+        internal static Option<bool> DebugRebuildCacheOption { get; } = new("--debug:rebuild-cache", "--debug:rebuildcache")
         {
             Description = SymbolStrings.Option_Debug_RebuildCache,
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliOption<bool> DebugShowConfigOption { get; } = new("--debug:show-config", "--debug:showconfig")
+        internal static Option<bool> DebugShowConfigOption { get; } = new("--debug:show-config", "--debug:showconfig")
         {
             Description = SymbolStrings.Option_Debug_ShowConfig,
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliArgument<string> ShortNameArgument { get; } = new("template-short-name")
+        internal static Argument<string> ShortNameArgument { get; } = new("template-short-name")
         {
             Description = SymbolStrings.Command_Instantiate_Argument_ShortName,
             Arity = new ArgumentArity(0, 1),
             Hidden = true
         };
 
-        internal static CliArgument<string[]> RemainingArguments { get; } = new("template-args")
+        internal static Argument<string[]> RemainingArguments { get; } = new("template-args")
         {
             Description = SymbolStrings.Command_Instantiate_Argument_TemplateOptions,
             Arity = new ArgumentArity(0, 999),
             Hidden = true
         };
 
-        internal IReadOnlyList<CliOption> PassByOptions { get; } = new CliOption[]
+        internal IReadOnlyList<Option> PassByOptions { get; } = new Option[]
         {
             SharedOptions.ForceOption,
             SharedOptions.NameOption,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs
index 559c3f73cd24..212fd2eb03df 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs
@@ -11,7 +11,7 @@ internal class NewCommandArgs : GlobalArgs
     {
         public NewCommandArgs(NewCommand command, ParseResult parseResult) : base(command, parseResult)
         {
-            List<CliToken> tokensToEvaluate = new();
+            List<Token> tokensToEvaluate = new();
             foreach (var childrenResult in parseResult.CommandResult.Children)
             {
                 if (childrenResult is OptionResult o)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ParserFactory.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ParserFactory.cs
index 9e1a78b02622..bf19f440af4d 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ParserFactory.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/ParserFactory.cs
@@ -8,9 +8,9 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal static class ParserFactory
     {
-        internal static CliConfiguration CreateParser(CliCommand command, bool disableHelp = false)
+        internal static CommandLineConfiguration CreateParser(Command command, bool disableHelp = false)
         {
-            CliConfiguration config = new(command)
+            CommandLineConfiguration config = new(command)
             //TODO: decide if it's needed to implement it; and implement if needed
             //.UseParseDirective()
             //.UseSuggestDirective()
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
index 0fae1afbea26..e9963f51aa21 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
@@ -7,35 +7,35 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     public static class SharedOptions
     {
-        public static CliOption<FileInfo> OutputOption { get; } = new("--output", "-o")
+        public static Option<FileInfo> OutputOption { get; } = new("--output", "-o")
         {
             Description = SymbolStrings.Option_Output,
             Required = false,
             Arity = new ArgumentArity(1, 1)
         };
 
-        public static CliOption<FileInfo> ProjectPathOption { get; } = new CliOption<FileInfo>("--project")
+        public static Option<FileInfo> ProjectPathOption { get; } = new Option<FileInfo>("--project")
         {
             Description = SymbolStrings.Option_ProjectPath
         }.AcceptExistingOnly();
 
-        public static CliOption<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption();
+        public static Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption();
 
-        internal static CliOption<bool> ForceOption { get; } = SharedOptionsFactory.CreateForceOption();
+        internal static Option<bool> ForceOption { get; } = SharedOptionsFactory.CreateForceOption();
 
-        internal static CliOption<string> NameOption { get; } = new("--name", "-n")
+        internal static Option<string> NameOption { get; } = new("--name", "-n")
         {
             Description = SymbolStrings.TemplateCommand_Option_Name,
             Arity = new ArgumentArity(1, 1)
         };
 
-        internal static CliOption<bool> DryRunOption { get; } = new("--dry-run")
+        internal static Option<bool> DryRunOption { get; } = new("--dry-run")
         {
             Description = SymbolStrings.TemplateCommand_Option_DryRun,
             Arity = new ArgumentArity(0, 1)
         };
 
-        internal static CliOption<bool> NoUpdateCheckOption { get; } = new("--no-update-check")
+        internal static Option<bool> NoUpdateCheckOption { get; } = new("--no-update-check")
         {
             Description = SymbolStrings.TemplateCommand_Option_NoUpdateCheck,
             Arity = new ArgumentArity(0, 1)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptionsFactory.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptionsFactory.cs
index c3bef7a70795..360b0ef6699d 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptionsFactory.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptionsFactory.cs
@@ -9,40 +9,40 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     public static class SharedOptionsFactory
     {
-        public static CliOption AsHidden(this CliOption o)
+        public static Option AsHidden(this Option o)
         {
             o.Hidden = true;
             return o;
         }
 
-        public static CliOption<T> AsHidden<T>(this CliOption<T> o)
+        public static Option<T> AsHidden<T>(this Option<T> o)
         {
             o.Hidden = true;
             return o;
         }
 
-        public static CliOption<T> WithDescription<T>(this CliOption<T> o, string description)
+        public static Option<T> WithDescription<T>(this Option<T> o, string description)
         {
             o.Description = description;
             return o;
         }
 
-        public static CliOption<T> DisableAllowMultipleArgumentsPerToken<T>(this CliOption<T> o)
+        public static Option<T> DisableAllowMultipleArgumentsPerToken<T>(this Option<T> o)
         {
             o.AllowMultipleArgumentsPerToken = false;
             return o;
         }
 
-        internal static CliOption<bool> CreateInteractiveOption()
+        internal static Option<bool> CreateInteractiveOption()
         {
-            return new CliOption<bool>("--interactive")
+            return new Option<bool>("--interactive")
             {
                 Arity = new ArgumentArity(0, 1),
                 Description = SymbolStrings.Option_Interactive
             };
         }
 
-        internal static CliOption<string[]> CreateAddSourceOption()
+        internal static Option<string[]> CreateAddSourceOption()
         {
             return new("--add-source", "--nuget-source")
             {
@@ -53,7 +53,7 @@ internal static CliOption<string[]> CreateAddSourceOption()
             };
         }
 
-        internal static CliOption<bool> CreateForceOption()
+        internal static Option<bool> CreateForceOption()
         {
             return new("--force")
             {
@@ -62,7 +62,7 @@ internal static CliOption<bool> CreateForceOption()
             };
         }
 
-        internal static CliOption<string> CreateAuthorOption()
+        internal static Option<string> CreateAuthorOption()
         {
             return new("--author")
             {
@@ -71,7 +71,7 @@ internal static CliOption<string> CreateAuthorOption()
             };
         }
 
-        internal static CliOption<string> CreateBaselineOption()
+        internal static Option<string> CreateBaselineOption()
         {
             return new("--baseline")
             {
@@ -81,7 +81,7 @@ internal static CliOption<string> CreateBaselineOption()
             };
         }
 
-        internal static CliOption<string> CreateLanguageOption()
+        internal static Option<string> CreateLanguageOption()
         {
             return new("--language", "-lang")
             {
@@ -90,7 +90,7 @@ internal static CliOption<string> CreateLanguageOption()
             };
         }
 
-        internal static CliOption<string> CreateTypeOption()
+        internal static Option<string> CreateTypeOption()
         {
             return new("--type")
             {
@@ -99,7 +99,7 @@ internal static CliOption<string> CreateTypeOption()
             };
         }
 
-        internal static CliOption<string> CreateTagOption()
+        internal static Option<string> CreateTagOption()
         {
             return new("--tag")
             {
@@ -108,7 +108,7 @@ internal static CliOption<string> CreateTagOption()
             };
         }
 
-        internal static CliOption<string> CreatePackageOption()
+        internal static Option<string> CreatePackageOption()
         {
             return new("--package")
             {
@@ -117,7 +117,7 @@ internal static CliOption<string> CreatePackageOption()
             };
         }
 
-        internal static CliOption<bool> CreateColumnsAllOption()
+        internal static Option<bool> CreateColumnsAllOption()
         {
             return new("--columns-all")
             {
@@ -126,9 +126,9 @@ internal static CliOption<bool> CreateColumnsAllOption()
             };
         }
 
-        internal static CliOption<string[]> CreateColumnsOption()
+        internal static Option<string[]> CreateColumnsOption()
         {
-            CliOption<string[]> option = new("--columns")
+            Option<string[]> option = new("--columns")
             {
                 Arity = new ArgumentArity(1, 4),
                 Description = SymbolStrings.Option_Columns,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs
index ef71e9bcb602..23e04dd714e2 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs
@@ -9,6 +9,7 @@
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Edge.Settings;
 using Microsoft.TemplateEngine.Utils;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
@@ -16,7 +17,7 @@ internal partial class InstantiateCommand
     {
         private const string Indent = "  ";
         private static Lazy<ResourceManager> _resourceManager = new(
-            () => new ResourceManager("System.CommandLine.Properties.Resources", typeof(System.CommandLine.CliSymbol).Assembly));
+            () => new ResourceManager("System.CommandLine.Properties.Resources", typeof(System.CommandLine.Symbol).Assembly));
 
         public static void WriteHelp(HelpContext context, InstantiateCommandArgs instantiateCommandArgs, IEngineEnvironmentSettings environmentSettings)
         {
@@ -287,7 +288,7 @@ internal static void ShowCommandOptions(
             IEnumerable<TemplateCommand> templatesToShow,
             HelpContext context)
         {
-            List<CliOption> optionsToShow = new()
+            List<Option> optionsToShow = new()
             {
                 SharedOptions.NameOption,
                 SharedOptions.OutputOption,
@@ -322,7 +323,7 @@ internal static void ShowCommandOptions(
                 }
             }
 
-            foreach (CliOption cliOption in optionsToShow)
+            foreach (Option cliOption in optionsToShow)
             {
                 cliOption.EnsureHelpName();
             }
@@ -367,7 +368,7 @@ internal static IEnumerable<TemplateCommand> GetMatchingTemplates(
             return matchingTemplates;
         }
 
-        internal static void ShowUsage(CliCommand? command, IReadOnlyList<string> shortNames, HelpContext context)
+        internal static void ShowUsage(Command? command, IReadOnlyList<string> shortNames, HelpContext context)
         {
             List<string> usageParts = new();
             while (command is not null)
@@ -376,7 +377,7 @@ internal static void ShowUsage(CliCommand? command, IReadOnlyList<string> shortN
                 {
                     usageParts.Add(command.Name);
                 }
-                command = command.Parents.FirstOrDefault(c => c is CliCommand) as CliCommand;
+                command = command.Parents.FirstOrDefault(c => c is Command) as Command;
             }
 
             usageParts.Reverse();
@@ -440,10 +441,10 @@ private static IEnumerable<TemplateOption> CollectOptionsToShow(IEnumerable<Temp
             return optionsToShow;
         }
 
-        private static void WriteCustomInstantiateHelp(HelpContext context, CliCommand command)
+        private static void WriteCustomInstantiateHelp(HelpContext context, Command command)
         {
             //unhide arguments of NewCommand. They are hidden not to appear in subcommands help.
-            foreach (CliArgument arg in command.Arguments)
+            foreach (Argument arg in command.Arguments)
             {
                 arg.Hidden = false;
             }
@@ -460,7 +461,7 @@ private static void WriteCustomInstantiateHelp(HelpContext context, CliCommand c
             context.Output.WriteLine();
         }
 
-        private static void CustomUsageSection(HelpContext context, CliCommand command)
+        private static void CustomUsageSection(HelpContext context, Command command)
         {
             context.Output.WriteLine(HelpUsageTitle());
             context.Output.WriteLine(Indent + string.Join(" ", GetCustomUsageParts(context, command, showSubcommands: false)));
@@ -473,21 +474,21 @@ private static void CustomUsageSection(HelpContext context, CliCommand command)
 
         private static IEnumerable<string> GetCustomUsageParts(
             HelpContext context,
-            CliCommand command,
+            Command command,
             bool showSubcommands = true,
             bool showArguments = true,
             bool showOptions = true)
         {
-            List<CliCommand> parentCommands = new();
-            CliCommand? nextCommand = command;
+            List<Command> parentCommands = new();
+            Command? nextCommand = command;
             while (nextCommand is not null)
             {
                 parentCommands.Add(nextCommand);
-                nextCommand = nextCommand.Parents.FirstOrDefault(c => c is CliCommand) as CliCommand;
+                nextCommand = nextCommand.Parents.FirstOrDefault(c => c is Command) as Command;
             }
             parentCommands.Reverse();
 
-            foreach (CliCommand parentCommand in parentCommands)
+            foreach (Command parentCommand in parentCommands)
             {
                 yield return parentCommand.Name;
             }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs
index 4f5800491918..fa20b5c64386 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs
@@ -5,7 +5,7 @@
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Edge.Settings;
-using Command = System.CommandLine.CliCommand;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
@@ -167,16 +167,16 @@ private static NewCommandStatus HandleNoTemplateFoundResult(
 
         private static void HandleNoMatchOnTemplateBaseOptions(IEnumerable<TemplateResult> matchInfos, InstantiateCommandArgs args, TemplateGroup templateGroup)
         {
-            CliOption<string> languageOption = SharedOptionsFactory.CreateLanguageOption();
-            CliOption<string> typeOption = SharedOptionsFactory.CreateTypeOption();
-            CliOption<string> baselineOption = SharedOptionsFactory.CreateBaselineOption();
+            Option<string> languageOption = SharedOptionsFactory.CreateLanguageOption();
+            Option<string> typeOption = SharedOptionsFactory.CreateTypeOption();
+            Option<string> baselineOption = SharedOptionsFactory.CreateBaselineOption();
 
             Command reparseCommand = new("reparse-only")
             {
                 languageOption,
                 typeOption,
                 baselineOption,
-                new CliArgument<string[]>("rem-args")
+                new Argument<string[]>("rem-args")
                 {
                     Arity = new ArgumentArity(0, 999)
                 }
@@ -184,7 +184,7 @@ private static void HandleNoMatchOnTemplateBaseOptions(IEnumerable<TemplateResul
 
             ParseResult result = ParserFactory.CreateParser(reparseCommand).Parse(args.RemainingArguments ?? Array.Empty<string>());
             string baseInputParameters = $"'{args.ShortName}'";
-            foreach (CliOption<string> option in new[] { languageOption, typeOption, baselineOption })
+            foreach (Option<string> option in new[] { languageOption, typeOption, baselineOption })
             {
                 if (result.GetResult(option) is { } optionResult && optionResult.IdentifierToken is { } token)
                 {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.TabCompletion.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.TabCompletion.cs
index 5dbd34f8485d..8056bb028fd3 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.TabCompletion.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.TabCompletion.cs
@@ -60,7 +60,7 @@ internal static IEnumerable<CompletionItem> GetTemplateCompletions(
                                 templateGroup,
                                 template);
 
-                            CliConfiguration parser = ParserFactory.CreateParser(command);
+                            CommandLineConfiguration parser = ParserFactory.CreateParser(command);
 
                             //it is important to pass raw text to get the completion
                             //completions for args passed as array are not supported
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
index af4b5ddb7362..160b78cb3de5 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
@@ -38,19 +38,19 @@ internal InstantiateCommand(
             Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ProjectPathOption));
         }
 
-        internal static CliArgument<string> ShortNameArgument { get; } = new CliArgument<string>("template-short-name")
+        internal static Argument<string> ShortNameArgument { get; } = new Argument<string>("template-short-name")
         {
             Description = SymbolStrings.Command_Instantiate_Argument_ShortName,
             Arity = new ArgumentArity(0, 1)
         };
 
-        internal CliArgument<string[]> RemainingArguments { get; } = new CliArgument<string[]>("template-args")
+        internal Argument<string[]> RemainingArguments { get; } = new Argument<string[]>("template-args")
         {
             Description = SymbolStrings.Command_Instantiate_Argument_TemplateOptions,
             Arity = new ArgumentArity(0, 999)
         };
 
-        internal IReadOnlyList<CliOption> PassByOptions { get; } = new CliOption[]
+        internal IReadOnlyList<Option> PassByOptions { get; } = new Option[]
         {
             SharedOptions.ForceOption,
             SharedOptions.NameOption,
@@ -434,7 +434,7 @@ private static (TemplateCommand? Command, ParseResult? ParseResult)? ReparseForT
                     template,
                     validateDefaultLanguage);
 
-                CliConfiguration parser = ParserFactory.CreateParser(command);
+                CommandLineConfiguration parser = ParserFactory.CreateParser(command);
                 ParseResult parseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
                 return (command, parseResult);
             }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
index 8f5a3e489ce4..f078574630c2 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
@@ -10,10 +10,11 @@
 using Microsoft.TemplateEngine.Edge;
 using Microsoft.TemplateEngine.Edge.Settings;
 using Microsoft.TemplateEngine.Utils;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class TemplateCommand : CliCommand
+    internal class TemplateCommand : Command
     {
         private static readonly TimeSpan ConstraintEvaluationTimeout = TimeSpan.FromMilliseconds(1000);
         private static readonly string[] _helpAliases = new[] { "-h", "/h", "--help", "-?", "/?" };
@@ -100,7 +101,7 @@ public TemplateCommand(
 
             if (HasRunScriptPostActionDefined(template))
             {
-                AllowScriptsOption = new CliOption<AllowRunScripts>("--allow-scripts")
+                AllowScriptsOption = new Option<AllowRunScripts>("--allow-scripts")
                 {
                     Description = SymbolStrings.TemplateCommand_Option_AllowScripts,
                     Arity = new ArgumentArity(1, 1),
@@ -114,13 +115,13 @@ public TemplateCommand(
 
         internal static IReadOnlyList<string> KnownHelpAliases => _helpAliases;
 
-        internal CliOption<AllowRunScripts>? AllowScriptsOption { get; }
+        internal Option<AllowRunScripts>? AllowScriptsOption { get; }
 
-        internal CliOption<string>? LanguageOption { get; }
+        internal Option<string>? LanguageOption { get; }
 
-        internal CliOption<string>? TypeOption { get; }
+        internal Option<string>? TypeOption { get; }
 
-        internal CliOption<string>? BaselineOption { get; }
+        internal Option<string>? BaselineOption { get; }
 
         internal IReadOnlyDictionary<string, TemplateOption> TemplateOptions => _templateSpecificOptions;
 
@@ -274,9 +275,9 @@ private HashSet<string> GetReservedAliases()
             }
             return reservedAliases;
 
-            static void AddReservedNamesAndAliases(HashSet<string> reservedAliases, CliCommand command)
+            static void AddReservedNamesAndAliases(HashSet<string> reservedAliases, Command command)
             {
-                foreach (CliOption option in command.Options)
+                foreach (Option option in command.Options)
                 {
                     reservedAliases.Add(option.Name);
                     foreach (string alias in option.Aliases)
@@ -284,7 +285,7 @@ static void AddReservedNamesAndAliases(HashSet<string> reservedAliases, CliComma
                         reservedAliases.Add(alias);
                     }
                 }
-                foreach (CliCommand subCommand in command.Subcommands)
+                foreach (Command subCommand in command.Subcommands)
                 {
                     reservedAliases.Add(subCommand.Name);
                     foreach (string alias in subCommand.Aliases)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommandArgs.cs
index 368bbcf6177c..cdcc2680513f 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommandArgs.cs
@@ -80,7 +80,7 @@ public TemplateCommandArgs(TemplateCommand command, BaseCommand parentCommand, P
 
         public ParseResult ParseResult { get; }
 
-        public CliCommand Command => _command;
+        public Command Command => _command;
 
         public NewCommand RootCommand { get; }
 
@@ -115,7 +115,7 @@ public bool TryGetAliasForCanonicalName(string canonicalName, out string? alias)
             {
                 throw new InvalidOperationException($"Parameter {parameterName} is not defined for {Template.Identity}.");
             }
-            if (parameter.Type == ParameterType.Hex && optionResult.Option is CliOption<long>)
+            if (parameter.Type == ParameterType.Hex && optionResult.Option is Option<long>)
             {
                 var intValue = (long)optionValue;
                 return $"0x{intValue.ToString("X")}";
@@ -129,10 +129,10 @@ private NewCommand GetRootCommand(BaseCommand command)
             {
                 return newCommand;
             }
-            CliCommand? currentCommand = command;
+            Command? currentCommand = command;
             while (currentCommand != null && currentCommand is not NewCommand)
             {
-                currentCommand = currentCommand.Parents.OfType<CliCommand>().SingleOrDefault();
+                currentCommand = currentCommand.Parents.OfType<Command>().SingleOrDefault();
             }
             return currentCommand as NewCommand ?? throw new Exception($"Command structure is not correct: {nameof(NewCommand)} is not found.");
         }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateOption.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateOption.cs
index f6b20702bfb8..61164096ca7b 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateOption.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateOption.cs
@@ -7,7 +7,7 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class TemplateOption : IEquatable<TemplateOption>
     {
-        private CliOption _option;
+        private Option _option;
 
         internal TemplateOption(
             CliTemplateParameter parameter,
@@ -22,7 +22,7 @@ internal TemplateOption(
 
         internal IReadOnlySet<string> Aliases { get; private set; }
 
-        internal CliOption Option => _option;
+        internal Option Option => _option;
 
         public bool Equals(TemplateOption? other)
         {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs
index 0f49518164f7..31224d978541 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs
@@ -19,22 +19,22 @@ internal DetailsCommand(
             Options.Add(AddSourceOption);
         }
 
-        internal static CliArgument<string> NameArgument { get; } = new("package-identifier")
+        internal static Argument<string> NameArgument { get; } = new("package-identifier")
         {
             Description = LocalizableStrings.DetailsCommand_Argument_PackageIdentifier,
             Arity = new ArgumentArity(1, 1)
         };
 
         // Option disabled until https://github.com/dotnet/templating/issues/6811 is solved
-        //internal static CliOption<string> VersionOption { get; } = new("-version", "--version")
+        //internal static Option<string> VersionOption { get; } = new("-version", "--version")
         //{
         //    Description = LocalizableStrings.DetailsCommand_Option_Version,
         //    Arity = new ArgumentArity(1, 1)
         //};
 
-        internal virtual CliOption<bool> InteractiveOption { get; } = SharedOptions.InteractiveOption;
+        internal virtual Option<bool> InteractiveOption { get; } = SharedOptions.InteractiveOption;
 
-        internal virtual CliOption<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
+        internal virtual Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
 
         protected override async Task<NewCommandStatus> ExecuteAsync(
             DetailsCommandArgs args,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
index dede54123642..b3821ebed5d1 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
@@ -22,17 +22,17 @@ internal BaseInstallCommand(
             Options.Add(ForceOption);
         }
 
-        internal static CliArgument<string[]> NameArgument { get; } = new("package")
+        internal static Argument<string[]> NameArgument { get; } = new("package")
         {
             Description = SymbolStrings.Command_Install_Argument_Package,
             Arity = new ArgumentArity(1, 99)
         };
 
-        internal static CliOption<bool> ForceOption { get; } = SharedOptionsFactory.CreateForceOption().WithDescription(SymbolStrings.Option_Install_Force);
+        internal static Option<bool> ForceOption { get; } = SharedOptionsFactory.CreateForceOption().WithDescription(SymbolStrings.Option_Install_Force);
 
-        internal virtual CliOption<bool> InteractiveOption { get; } = SharedOptions.InteractiveOption;
+        internal virtual Option<bool> InteractiveOption { get; } = SharedOptions.InteractiveOption;
 
-        internal virtual CliOption<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
+        internal virtual Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
 
         protected NewCommand ParentCommand { get; }
 
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
index 7f322dce877d..3d7688e5dab1 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
@@ -15,12 +15,12 @@ public LegacyInstallCommand(NewCommand parentCommand, Func<ParseResult, ITemplat
             Hidden = true;
             Aliases.Add("-i");
 
-            parentCommand.AddNoLegacyUsageValidators(this, except: new CliOption[] { InteractiveOption, AddSourceOption });
+            parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
         }
 
-        internal override CliOption<bool> InteractiveOption => ParentCommand.InteractiveOption;
+        internal override Option<bool> InteractiveOption => ParentCommand.InteractiveOption;
 
-        internal override CliOption<string[]> AddSourceOption => ParentCommand.AddSourceOption;
+        internal override Option<string[]> AddSourceOption => ParentCommand.AddSourceOption;
 
         protected override Task<NewCommandStatus> ExecuteAsync(InstallCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
index 5fa468745a22..5bdece74b64c 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
@@ -34,19 +34,19 @@ internal BaseListCommand(
             SetupTabularOutputOptions(this);
         }
 
-        public virtual CliOption<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
+        public virtual Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
 
-        public virtual CliOption<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
+        public virtual Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
 
-        public IReadOnlyDictionary<FilterOptionDefinition, CliOption> Filters { get; protected set; }
+        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; protected set; }
 
-        internal static CliOption<bool> IgnoreConstraintsOption { get; } = new("--ignore-constraints")
+        internal static Option<bool> IgnoreConstraintsOption { get; } = new("--ignore-constraints")
         {
             Description = SymbolStrings.ListCommand_Option_IgnoreConstraints,
             Arity = new ArgumentArity(0, 1)
         };
 
-        internal static CliArgument<string> NameArgument { get; } = new("template-name")
+        internal static Argument<string> NameArgument { get; } = new("template-name")
         {
             Description = SymbolStrings.Command_List_Argument_Name,
             Arity = new ArgumentArity(0, 1)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
index ebe50dcb2480..348f3eff3bc3 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
@@ -19,14 +19,14 @@ public LegacyListCommand(
             Aliases.Add("-l");
             Validators.Add(ValidateParentCommandArguments);
 
-            parentCommand.AddNoLegacyUsageValidators(this, except: Filters.Values.Concat(new CliSymbol[] { ColumnsAllOption, ColumnsOption, NewCommand.ShortNameArgument }).ToArray());
+            parentCommand.AddNoLegacyUsageValidators(this, except: Filters.Values.Concat(new Symbol[] { ColumnsAllOption, ColumnsOption, NewCommand.ShortNameArgument }).ToArray());
         }
 
-        public override CliOption<bool> ColumnsAllOption => ParentCommand.ColumnsAllOption;
+        public override Option<bool> ColumnsAllOption => ParentCommand.ColumnsAllOption;
 
-        public override CliOption<string[]> ColumnsOption => ParentCommand.ColumnsOption;
+        public override Option<string[]> ColumnsOption => ParentCommand.ColumnsOption;
 
-        protected override CliOption GetFilterOption(FilterOptionDefinition def)
+        protected override Option GetFilterOption(FilterOptionDefinition def)
         {
             return ParentCommand.LegacyFilters[def];
         }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
index 4602c70bed46..25d52fc404cf 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
@@ -33,13 +33,13 @@ internal BaseSearchCommand(
             SetupTabularOutputOptions(this);
         }
 
-        public virtual CliOption<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
+        public virtual Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
 
-        public virtual CliOption<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
+        public virtual Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
 
-        public IReadOnlyDictionary<FilterOptionDefinition, CliOption> Filters { get; protected set; }
+        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; protected set; }
 
-        internal static CliArgument<string> NameArgument { get; } = new("template-name")
+        internal static Argument<string> NameArgument { get; } = new("template-name")
         {
             Description = SymbolStrings.Command_Search_Argument_Name,
             Arity = new ArgumentArity(0, 1)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
index 6658cdb9fd8a..9c7ad1f2d7fc 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
@@ -16,14 +16,14 @@ public LegacySearchCommand(NewCommand parentCommand, Func<ParseResult, ITemplate
             Hidden = true;
             Validators.Add(ValidateParentCommandArguments);
 
-            parentCommand.AddNoLegacyUsageValidators(this, except: Filters.Values.Concat(new CliSymbol[] { ColumnsAllOption, ColumnsOption, NewCommand.ShortNameArgument }).ToArray());
+            parentCommand.AddNoLegacyUsageValidators(this, except: Filters.Values.Concat(new Symbol[] { ColumnsAllOption, ColumnsOption, NewCommand.ShortNameArgument }).ToArray());
         }
 
-        public override CliOption<bool> ColumnsAllOption => ParentCommand.ColumnsAllOption;
+        public override Option<bool> ColumnsAllOption => ParentCommand.ColumnsAllOption;
 
-        public override CliOption<string[]> ColumnsOption => ParentCommand.ColumnsOption;
+        public override Option<string[]> ColumnsOption => ParentCommand.ColumnsOption;
 
-        protected override CliOption GetFilterOption(FilterOptionDefinition def)
+        protected override Option GetFilterOption(FilterOptionDefinition def)
         {
             return ParentCommand.LegacyFilters[def];
         }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
index a862d13f0139..aaeff1a38c6a 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
@@ -17,7 +17,7 @@ internal BaseUninstallCommand(
             Arguments.Add(NameArgument);
         }
 
-        internal static CliArgument<string[]> NameArgument { get; } = new("package")
+        internal static Argument<string[]> NameArgument { get; } = new("package")
         {
             Description = SymbolStrings.Command_Uninstall_Argument_Package,
             Arity = new ArgumentArity(0, 99)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
index 9cdfea6fd3aa..41d6a14d1145 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
@@ -21,9 +21,9 @@ internal BaseUpdateCommand(
             Options.Add(AddSourceOption);
         }
 
-        internal virtual CliOption<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption();
+        internal virtual Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption();
 
-        internal virtual CliOption<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
+        internal virtual Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
 
         protected NewCommand ParentCommand { get; }
 
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
index cc29a4a64e87..01042ccbb006 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
@@ -15,12 +15,12 @@ public LegacyUpdateApplyCommand(
             : base(parentCommand, hostBuilder, "--update-apply", SymbolStrings.Command_Legacy_Update_Check_Description)
         {
             Hidden = true;
-            parentCommand.AddNoLegacyUsageValidators(this, except: new CliOption[] { InteractiveOption, AddSourceOption });
+            parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
         }
 
-        internal override CliOption<bool> InteractiveOption => ParentCommand.InteractiveOption;
+        internal override Option<bool> InteractiveOption => ParentCommand.InteractiveOption;
 
-        internal override CliOption<string[]> AddSourceOption => ParentCommand.AddSourceOption;
+        internal override Option<string[]> AddSourceOption => ParentCommand.AddSourceOption;
 
         protected override Task<NewCommandStatus> ExecuteAsync(UpdateCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
index f84acbfa4815..da0b0caa460a 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
@@ -15,12 +15,12 @@ public LegacyUpdateCheckCommand(
             : base(parentCommand, hostBuilder, "--update-check", SymbolStrings.Command_Update_Description)
         {
             Hidden = true;
-            parentCommand.AddNoLegacyUsageValidators(this, except: new CliOption[] { InteractiveOption, AddSourceOption });
+            parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
         }
 
-        internal override CliOption<bool> InteractiveOption => ParentCommand.InteractiveOption;
+        internal override Option<bool> InteractiveOption => ParentCommand.InteractiveOption;
 
-        internal override CliOption<string[]> AddSourceOption => ParentCommand.AddSourceOption;
+        internal override Option<string[]> AddSourceOption => ParentCommand.AddSourceOption;
 
         protected override Task<NewCommandStatus> ExecuteAsync(UpdateCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
index 7ce595c91b36..276460d27359 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
@@ -18,7 +18,7 @@ public UpdateCommand(
             Options.Add(CheckOnlyOption);
         }
 
-        internal static CliOption<bool> CheckOnlyOption { get; } = new("--check-only", "--dry-run")
+        internal static Option<bool> CheckOnlyOption { get; } = new("--check-only", "--dry-run")
         {
             Description = SymbolStrings.Command_Update_Option_CheckOnly
         };
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs b/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
index b994c80a5f7b..eae0deeb2141 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
@@ -8,7 +8,7 @@ namespace Microsoft.TemplateEngine.Cli
 {
     public static class NewCommandFactory
     {
-        public static CliCommand Create(string commandName, Func<ParseResult, ICliTemplateEngineHost> hostBuilder)
+        public static Command Create(string commandName, Func<ParseResult, ICliTemplateEngineHost> hostBuilder)
         {
             if (string.IsNullOrWhiteSpace(commandName))
             {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/SymbolExtensions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/SymbolExtensions.cs
index e65a3f026857..33aee0c36a9e 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/SymbolExtensions.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/SymbolExtensions.cs
@@ -8,13 +8,13 @@ namespace Microsoft.TemplateEngine.Cli
 {
     public static class SymbolExtensions
     {
-        public static void EnsureHelpName(this CliOption cliOption)
+        public static void EnsureHelpName(this Option cliOption)
         {
             // System.CommandLine used to include the option's name without the prefix in the help output:
             // --name, --alias, -a <name> description
             // To keep that behavior, we need to set HelpName in explicit way.
             if (cliOption.HelpName is null
-                && cliOption is not CliOption<bool> // that was never a thing for boolean options
+                && cliOption is not Option<bool> // that was never a thing for boolean options
                 && cliOption.CompletionSources.Count == 0) // and options that have completions
             {
                 cliOption.HelpName = cliOption.Name.RemovePrefix();
diff --git a/src/Cli/dotnet-new3/CompleteCommand.cs b/src/Cli/dotnet-new3/CompleteCommand.cs
index 4a3fc7f95fe9..ba49516a245f 100644
--- a/src/Cli/dotnet-new3/CompleteCommand.cs
+++ b/src/Cli/dotnet-new3/CompleteCommand.cs
@@ -13,11 +13,11 @@ namespace Dotnet_new3
     /// this implementation is for test purpose only.
     /// Keep in sync with https://github.com/dotnet/sdk/blob/main/src/Cli/dotnet/commands/dotnet-complete/CompleteCommand.cs.
     /// </remark>
-    internal class CompleteCommand : CliCommand
+    internal class CompleteCommand : Command
     {
-        private static readonly CliArgument<string> PathArgument = new("path");
+        private static readonly Argument<string> PathArgument = new("path");
 
-        private static readonly CliOption<int?> PositionOption = new("--position");
+        private static readonly Option<int?> PositionOption = new("--position");
 
         internal CompleteCommand() : base("complete", "tab completion")
         {
@@ -40,7 +40,7 @@ public Task<int> Run(ParseResult result, CancellationToken cancellationToken)
                     input += " ";
                 }
 
-                CliCommand newCommand = New3CommandFactory.Create();
+                Command newCommand = New3CommandFactory.Create();
                 ParseResult newCommandResult = ParserFactory.CreateParser(newCommand).Parse(input);
                 foreach (CompletionItem suggestion in newCommandResult.GetCompletions(position).Distinct())
                 {
diff --git a/src/Cli/dotnet-new3/New3CommandFactory.cs b/src/Cli/dotnet-new3/New3CommandFactory.cs
index 9b0960157ee3..101398e52d90 100644
--- a/src/Cli/dotnet-new3/New3CommandFactory.cs
+++ b/src/Cli/dotnet-new3/New3CommandFactory.cs
@@ -11,21 +11,21 @@ internal static class New3CommandFactory
     {
         private const string CommandName = "new3";
 
-        private static readonly CliOption<bool> _debugEmitTelemetryOption = new("--debug:emit-telemetry", "Enable telemetry")
+        private static readonly Option<bool> _debugEmitTelemetryOption = new("--debug:emit-telemetry", "Enable telemetry")
         {
             Hidden = true,
             Recursive = true,
         };
 
-        private static readonly CliOption<bool> _debugDisableBuiltInTemplatesOption = new("--debug:disable-sdk-templates", "Disable built-in templates")
+        private static readonly Option<bool> _debugDisableBuiltInTemplatesOption = new("--debug:disable-sdk-templates", "Disable built-in templates")
         {
             Hidden = true,
             Recursive = true
         };
 
-        internal static CliCommand Create()
+        internal static Command Create()
         {
-            CliCommand newCommand = NewCommandFactory.Create(
+            Command newCommand = NewCommandFactory.Create(
                 CommandName,
                 (ParseResult parseResult) =>
                 {
diff --git a/src/Cli/dotnet-new3/ParserFactory.cs b/src/Cli/dotnet-new3/ParserFactory.cs
index 6116ed16c203..b6be21c0d713 100644
--- a/src/Cli/dotnet-new3/ParserFactory.cs
+++ b/src/Cli/dotnet-new3/ParserFactory.cs
@@ -9,9 +9,9 @@ namespace Dotnet_new3
 {
     internal static class ParserFactory
     {
-        internal static CliConfiguration CreateParser(CliCommand command, bool disableHelp = false)
+        internal static CommandLineConfiguration CreateParser(Command command, bool disableHelp = false)
         {
-            CliConfiguration config = new(command)
+            CommandLineConfiguration config = new(command)
             //.UseExceptionHandler(ExceptionHandler)
             //.UseLocalizationResources(new CommandLineValidationMessages())
             //TODO: decide if it's needed to implement it; and implement if needed
diff --git a/src/Cli/dotnet-new3/Program.cs b/src/Cli/dotnet-new3/Program.cs
index 62fa28534c6e..769ffbf6837c 100644
--- a/src/Cli/dotnet-new3/Program.cs
+++ b/src/Cli/dotnet-new3/Program.cs
@@ -21,7 +21,7 @@ public static Task<int> Main(string[] args)
                 }
             }
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             rootCommand.Subcommands.Add(New3CommandFactory.Create());
             return ParserFactory.CreateParser(rootCommand).Parse(args).InvokeAsync();
         }
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 95a86ec9984b..00ed6a416732 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -11,7 +11,7 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class CommonOptions
     {
-        public static CliOption<string[]> PropertiesOption =
+        public static Option<string[]> PropertiesOption =
             // these are all of the forms that the property switch can be understood by in MSBuild
             new ForwardedOption<string[]>("--property", "-property", "/property", "/p", "-p", "--p")
             {
@@ -19,14 +19,14 @@ internal static class CommonOptions
             }.ForwardAsProperty()
             .AllowSingleArgPerToken();
 
-        public static CliOption<VerbosityOptions> VerbosityOption =
+        public static Option<VerbosityOptions> VerbosityOption =
             new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
             {
                 Description = CommonLocalizableStrings.VerbosityOptionDescription,
                 HelpName = CommonLocalizableStrings.LevelArgumentName
             }.ForwardAsSingle(o => $"-verbosity:{o}");
 
-        public static CliOption<VerbosityOptions> HiddenVerbosityOption =
+        public static Option<VerbosityOptions> HiddenVerbosityOption =
             new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
             {
                 Description = CommonLocalizableStrings.VerbosityOptionDescription,
@@ -34,7 +34,7 @@ internal static class CommonOptions
                 Hidden = true
             }.ForwardAsSingle(o => $"-verbosity:{o}");
 
-        public static CliOption<string> FrameworkOption(string description) =>
+        public static Option<string> FrameworkOption(string description) =>
             new ForwardedOption<string>("--framework", "-f")
             {
                 Description = description,
@@ -43,7 +43,7 @@ public static CliOption<string> FrameworkOption(string description) =>
             }.ForwardAsSingle(o => $"-property:TargetFramework={o}")
             .AddCompletions(Complete.TargetFrameworksFromProjectFile);
 
-        public static CliOption<string> ArtifactsPathOption =
+        public static Option<string> ArtifactsPathOption =
             new ForwardedOption<string>(
                 //  --artifacts-path is pretty verbose, should we use --artifacts instead (or possibly support both)?
                 "--artifacts-path")
@@ -62,27 +62,27 @@ public static IEnumerable<string> RuntimeArgFunc(string rid)
             return new string[] { $"-property:RuntimeIdentifier={rid}", "-property:_CommandLineDefinedRuntimeIdentifier=true" };
         }
 
-        public static CliOption<string> RuntimeOption =
+        public static Option<string> RuntimeOption =
             new ForwardedOption<string>("--runtime", "-r")
             {
                 HelpName = RuntimeArgName
             }.ForwardAsMany(RuntimeArgFunc)
             .AddCompletions(Complete.RunTimesFromProjectFile);
 
-        public static CliOption<string> LongFormRuntimeOption =
+        public static Option<string> LongFormRuntimeOption =
             new ForwardedOption<string>("--runtime")
             {
                 HelpName = RuntimeArgName
             }.ForwardAsMany(RuntimeArgFunc)
             .AddCompletions(Complete.RunTimesFromProjectFile);
 
-        public static CliOption<bool> CurrentRuntimeOption(string description) =>
+        public static Option<bool> CurrentRuntimeOption(string description) =>
             new ForwardedOption<bool>("--use-current-runtime", "--ucr")
             {
                 Description = description
             }.ForwardAs("-property:UseCurrentRuntimeIdentifier=True");
 
-        public static CliOption<string> ConfigurationOption(string description) =>
+        public static Option<string> ConfigurationOption(string description) =>
             new ForwardedOption<string>("--configuration", "-c")
             {
                 Description = description,
@@ -90,7 +90,7 @@ public static CliOption<string> ConfigurationOption(string description) =>
             }.ForwardAsSingle(o => $"-property:Configuration={o}")
             .AddCompletions(Complete.ConfigurationsFromProjectFileOrDefaults);
 
-        public static CliOption<string> VersionSuffixOption =
+        public static Option<string> VersionSuffixOption =
             new ForwardedOption<string>("--version-suffix")
             {
                 Description = CommonLocalizableStrings.CmdVersionSuffixDescription,
@@ -99,7 +99,7 @@ public static CliOption<string> ConfigurationOption(string description) =>
 
         public static Lazy<string> NormalizedCurrentDirectory = new(() => PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory()));
 
-        public static CliArgument<string> DefaultToCurrentDirectory(this CliArgument<string> arg)
+        public static Argument<string> DefaultToCurrentDirectory(this Argument<string> arg)
         {
             // we set this lazily so that we don't pay the overhead of determining the
             // CWD multiple times, one for each Argument that uses this.
@@ -107,38 +107,38 @@ public static CliArgument<string> DefaultToCurrentDirectory(this CliArgument<str
             return arg;
         }
 
-        public static CliOption<bool> NoRestoreOption = new ForwardedOption<bool>("--no-restore")
+        public static Option<bool> NoRestoreOption = new ForwardedOption<bool>("--no-restore")
         {
             Description = CommonLocalizableStrings.NoRestoreDescription
         }.ForwardAs("-restore:false");
 
-        public static CliOption<bool> InteractiveMsBuildForwardOption =
+        public static Option<bool> InteractiveMsBuildForwardOption =
             new ForwardedOption<bool>("--interactive")
             {
                 Description = CommonLocalizableStrings.CommandInteractiveOptionDescription
             }.ForwardAs("-property:NuGetInteractive=true");
 
-        public static CliOption<bool> InteractiveOption =
+        public static Option<bool> InteractiveOption =
             new("--interactive")
             {
                 Description = CommonLocalizableStrings.CommandInteractiveOptionDescription
             };
 
-        public static CliOption<bool> DisableBuildServersOption =
+        public static Option<bool> DisableBuildServersOption =
             new ForwardedOption<bool>("--disable-build-servers")
             {
                 Description = CommonLocalizableStrings.DisableBuildServersOptionDescription
             }
             .ForwardAsMany(_ => ["--property:UseRazorBuildServer=false", "--property:UseSharedCompilation=false", "/nodeReuse:false"]);
 
-        public static CliOption<string> ArchitectureOption =
+        public static Option<string> ArchitectureOption =
             new ForwardedOption<string>("--arch", "-a")
             {
                 Description = CommonLocalizableStrings.ArchitectureOptionDescription,
                 HelpName = CommonLocalizableStrings.ArchArgumentName
             }.SetForwardingFunction(ResolveArchOptionToRuntimeIdentifier);
 
-        public static CliOption<string> LongFormArchitectureOption =
+        public static Option<string> LongFormArchitectureOption =
             new ForwardedOption<string>("--arch")
             {
                 Description = CommonLocalizableStrings.ArchitectureOptionDescription,
@@ -150,23 +150,23 @@ internal static string ArchOptionValue(ParseResult parseResult) =>
                 parseResult.GetValue(LongFormArchitectureOption) :
                 parseResult.GetValue(ArchitectureOption);
 
-        public static CliOption<string> OperatingSystemOption =
+        public static Option<string> OperatingSystemOption =
             new ForwardedOption<string>("--os")
             {
                 Description = CommonLocalizableStrings.OperatingSystemOptionDescription,
                 HelpName = CommonLocalizableStrings.OSArgumentName
             }.SetForwardingFunction(ResolveOsOptionToRuntimeIdentifier);
 
-        public static CliOption<bool> DebugOption = new("--debug");
+        public static Option<bool> DebugOption = new("--debug");
 
-        public static CliOption<bool> SelfContainedOption =
+        public static Option<bool> SelfContainedOption =
             new ForwardedOption<bool>("--self-contained", "--sc")
             {
                 Description = CommonLocalizableStrings.SelfContainedOptionDescription
             }
             .SetForwardingFunction(ForwardSelfContainedOptions);
 
-        public static CliOption<bool> NoSelfContainedOption =
+        public static Option<bool> NoSelfContainedOption =
             new ForwardedOption<bool>("--no-self-contained")
             {
                 Description = CommonLocalizableStrings.FrameworkDependentOptionDescription
@@ -174,11 +174,11 @@ internal static string ArchOptionValue(ParseResult parseResult) =>
             // Flip the argument so that if this option is specified we get selfcontained=false
             .SetForwardingFunction((arg, p) => ForwardSelfContainedOptions(!arg, p));
 
-        public static readonly CliOption<string> TestPlatformOption = new("--Platform");
+        public static readonly Option<string> TestPlatformOption = new("--Platform");
 
-        public static readonly CliOption<string> TestFrameworkOption = new("--Framework");
+        public static readonly Option<string> TestFrameworkOption = new("--Framework");
 
-        public static readonly CliOption<string[]> TestLoggerOption = new("--logger");
+        public static readonly Option<string[]> TestLoggerOption = new("--logger");
 
         public static void ValidateSelfContainedOptions(bool hasSelfContainedOption, bool hasNoSelfContainedOption)
         {
@@ -266,13 +266,13 @@ private static bool UserSpecifiedRidOption(ParseResult parseResult) =>
             parseResult.GetResult(LongFormArchitectureOption) ??
             parseResult.GetResult(OperatingSystemOption)) is not null;
 
-        internal static CliOption<T> AddCompletions<T>(this CliOption<T> option, Func<CompletionContext, IEnumerable<CompletionItem>> completionSource)
+        internal static Option<T> AddCompletions<T>(this Option<T> option, Func<CompletionContext, IEnumerable<CompletionItem>> completionSource)
         {
             option.CompletionSources.Add(completionSource);
             return option;
         }
 
-        internal static CliArgument<T> AddCompletions<T>(this CliArgument<T> argument, Func<CompletionContext, IEnumerable<CompletionItem>> completionSource)
+        internal static Argument<T> AddCompletions<T>(this Argument<T> argument, Func<CompletionContext, IEnumerable<CompletionItem>> completionSource)
         {
             argument.CompletionSources.Add(completionSource);
             return argument;
diff --git a/src/Cli/dotnet/CommonOptionsFactory.cs b/src/Cli/dotnet/CommonOptionsFactory.cs
index 82ef38d3af63..304fbb858562 100644
--- a/src/Cli/dotnet/CommonOptionsFactory.cs
+++ b/src/Cli/dotnet/CommonOptionsFactory.cs
@@ -13,7 +13,7 @@ internal static class CommonOptionsFactory
         /// <summary>
         /// Creates common diagnositcs option (-d|--diagnostics).
         /// </summary>
-        public static CliOption<bool> CreateDiagnosticsOption(bool recursive) => new("--diagnostics", "-d")
+        public static Option<bool> CreateDiagnosticsOption(bool recursive) => new("--diagnostics", "-d")
         {
             Description = Tools.Help.LocalizableStrings.SDKDiagnosticsCommandDefinition,
             Recursive = recursive
diff --git a/src/Cli/dotnet/DocumentedCommand.cs b/src/Cli/dotnet/DocumentedCommand.cs
index 53b346eaf5ab..a74cea56034c 100644
--- a/src/Cli/dotnet/DocumentedCommand.cs
+++ b/src/Cli/dotnet/DocumentedCommand.cs
@@ -6,7 +6,7 @@
 
 namespace Microsoft.DotNet.Cli
 {
-    public class DocumentedCommand : CliCommand, ICommandDocument
+    public class DocumentedCommand : Command, ICommandDocument
     {
         public string DocsLink { get; }
 
diff --git a/src/Cli/dotnet/DotNetCommandFactory.cs b/src/Cli/dotnet/DotNetCommandFactory.cs
index 190b2385abde..2d952593c96b 100644
--- a/src/Cli/dotnet/DotNetCommandFactory.cs
+++ b/src/Cli/dotnet/DotNetCommandFactory.cs
@@ -40,7 +40,7 @@ public ICommand Create(
         private bool TryGetBuiltInCommand(string commandName, out Func<string[], int> commandFunc)
         {
             var command = Parser.GetBuiltInCommand(commandName);
-            if (command?.Action is AsynchronousCliAction action)
+            if (command?.Action is AsynchronousCommandLineAction action)
             {
                 commandFunc = (args) => action.InvokeAsync(Parser.Instance.Parse(args)).Result;
                 return true;
diff --git a/src/Cli/dotnet/NugetSearch/NugetSearchApiParameter.cs b/src/Cli/dotnet/NugetSearch/NugetSearchApiParameter.cs
index c2d26cfc9af0..6055f84795a0 100644
--- a/src/Cli/dotnet/NugetSearch/NugetSearchApiParameter.cs
+++ b/src/Cli/dotnet/NugetSearch/NugetSearchApiParameter.cs
@@ -40,7 +40,7 @@ public NugetSearchApiParameter(ParseResult parseResult)
             Prerelease = prerelease;
         }
 
-        private static int? GetParsedResultAsInt(ParseResult parseResult, CliOption<string> alias)
+        private static int? GetParsedResultAsInt(ParseResult parseResult, Option<string> alias)
         {
             var valueFromParser = parseResult.GetValue(alias);
             if (string.IsNullOrWhiteSpace(valueFromParser))
diff --git a/src/Cli/dotnet/OptionForwardingExtensions.cs b/src/Cli/dotnet/OptionForwardingExtensions.cs
index 864c26e78acb..5ee1ba2c039c 100644
--- a/src/Cli/dotnet/OptionForwardingExtensions.cs
+++ b/src/Cli/dotnet/OptionForwardingExtensions.cs
@@ -47,17 +47,17 @@ public static ForwardedOption<string[]> ForwardAsProperty(this ForwardedOption<s
                     .Select(keyValue => $"{option.Name}:{keyValue.key}={keyValue.value}")
                 );
 
-        public static CliOption<T> ForwardAsMany<T>(this ForwardedOption<T> option, Func<T, IEnumerable<string>> format) => option.SetForwardingFunction(format);
+        public static Option<T> ForwardAsMany<T>(this ForwardedOption<T> option, Func<T, IEnumerable<string>> format) => option.SetForwardingFunction(format);
 
-        public static CliOption<IEnumerable<string>> ForwardAsManyArgumentsEachPrefixedByOption(this ForwardedOption<IEnumerable<string>> option, string alias) => option.ForwardAsMany(o => ForwardedArguments(alias, o));
+        public static Option<IEnumerable<string>> ForwardAsManyArgumentsEachPrefixedByOption(this ForwardedOption<IEnumerable<string>> option, string alias) => option.ForwardAsMany(o => ForwardedArguments(alias, o));
 
-        public static IEnumerable<string> OptionValuesToBeForwarded(this ParseResult parseResult, CliCommand command) =>
+        public static IEnumerable<string> OptionValuesToBeForwarded(this ParseResult parseResult, Command command) =>
             command.Options
                 .OfType<IForwardedOption>()
                 .SelectMany(o => o.GetForwardingFunction()(parseResult)) ?? Array.Empty<string>();
 
 
-        public static IEnumerable<string> ForwardedOptionValues<T>(this ParseResult parseResult, CliCommand command, string alias) =>
+        public static IEnumerable<string> ForwardedOptionValues<T>(this ParseResult parseResult, Command command, string alias) =>
             command.Options?
                 .Where(o => o.Name.Equals(alias) || o.Aliases.Contains(alias))?
                 .OfType<IForwardedOption>()?
@@ -65,21 +65,21 @@ public static IEnumerable<string> ForwardedOptionValues<T>(this ParseResult pars
                 .GetForwardingFunction()(parseResult)
             ?? Array.Empty<string>();
 
-        public static CliOption<T> AllowSingleArgPerToken<T>(this CliOption<T> option)
+        public static Option<T> AllowSingleArgPerToken<T>(this Option<T> option)
         {
             option.AllowMultipleArgumentsPerToken = false;
             return option;
         }
 
-        public static CliOption<T> Hide<T>(this CliOption<T> option)
+        public static Option<T> Hide<T>(this Option<T> option)
         {
             option.Hidden = true;
             return option;
         }
 
-        internal static Dictionary<CliOption, Dictionary<CliCommand, string>> HelpDescriptionCustomizations = new();
+        internal static Dictionary<Option, Dictionary<Command, string>> HelpDescriptionCustomizations = new();
 
-        public static CliOption<T> WithHelpDescription<T>(this CliOption<T> option, CliCommand command, string helpText)
+        public static Option<T> WithHelpDescription<T>(this Option<T> option, Command command, string helpText)
         {
             if (HelpDescriptionCustomizations.ContainsKey(option))
             {
@@ -87,7 +87,7 @@ public static CliOption<T> WithHelpDescription<T>(this CliOption<T> option, CliC
             }
             else
             {
-                HelpDescriptionCustomizations.Add(option, new Dictionary<CliCommand, string>() { { command, helpText } });
+                HelpDescriptionCustomizations.Add(option, new Dictionary<Command, string>() { { command, helpText } });
             }
 
             return option;
@@ -108,7 +108,7 @@ public interface IForwardedOption
         Func<ParseResult, IEnumerable<string>> GetForwardingFunction();
     }
 
-    public class ForwardedOption<T> : CliOption<T>, IForwardedOption
+    public class ForwardedOption<T> : Option<T>, IForwardedOption
     {
         private Func<ParseResult, IEnumerable<string>> ForwardingFunction;
 
diff --git a/src/Cli/dotnet/ParseResultExtensions.cs b/src/Cli/dotnet/ParseResultExtensions.cs
index faac5cb2ed1f..9642ec43ce61 100644
--- a/src/Cli/dotnet/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/ParseResultExtensions.cs
@@ -29,7 +29,7 @@ public static void ShowHelp(this ParseResult parseResult)
         {
             // take from the start of the list until we hit an option/--/unparsed token
             // since commands can have arguments, we must take those as well in order to get accurate help
-            var tokenList = parseResult.Tokens.TakeWhile(token => token.Type == CliTokenType.Argument || token.Type == CliTokenType.Command || token.Type == CliTokenType.Directive).Select(t => t.Value).ToList();
+            var tokenList = parseResult.Tokens.TakeWhile(token => token.Type is TokenType.Argument or TokenType.Command or TokenType.Directive).Select(t => t.Value).ToList();
             tokenList.Add("-h");
             Instance.Parse(tokenList).Invoke();
         }
@@ -96,13 +96,13 @@ public static bool IsDotnetBuiltInCommand(this ParseResult parseResult)
 
         public static bool IsTopLevelDotnetCommand(this ParseResult parseResult)
         {
-            return parseResult.CommandResult.Command.Equals(RootCommand) && string.IsNullOrEmpty(parseResult.RootSubCommandResult());
+            return parseResult.CommandResult.Command.Equals(Parser.RootCommand) && string.IsNullOrEmpty(parseResult.RootSubCommandResult());
         }
 
         public static bool CanBeInvoked(this ParseResult parseResult)
         {
             return GetBuiltInCommand(parseResult.RootSubCommandResult()) != null ||
-                parseResult.Tokens.Any(token => token.Type == CliTokenType.Directive) ||
+                parseResult.Tokens.Any(token => token.Type == TokenType.Directive) ||
                 (parseResult.IsTopLevelDotnetCommand() && string.IsNullOrEmpty(parseResult.GetValue(DotnetSubCommand)));
         }
 
@@ -222,14 +222,14 @@ private static IEnumerable<string> GetRunPropertyOptions(ParseResult parseResult
             var propertyValues = propertyOptions.SelectMany(o => o.Tokens.Select(t => t.Value)).ToArray();
             return propertyValues;
 
-            static CliToken GetOptionTokenOrDefault(SymbolResult symbolResult)
+            static Token GetOptionTokenOrDefault(SymbolResult symbolResult)
             {
                 if (symbolResult is not OptionResult optionResult)
                 {
                     return null;
                 }
 
-                return optionResult.IdentifierToken ?? new CliToken($"--{optionResult.Option.Name}", CliTokenType.Option, optionResult.Option);
+                return optionResult.IdentifierToken ?? new Token($"--{optionResult.Option.Name}", TokenType.Option, optionResult.Option);
             }
         }
 
@@ -248,7 +248,7 @@ public static void HandleDebugSwitch(this ParseResult parseResult)
         /// If you are inside a command handler or 'normal' System.CommandLine code then you don't need this - the parse error handling
         /// will have covered these cases.
         /// </summary>
-        public static T SafelyGetValueForOption<T>(this ParseResult parseResult, CliOption<T> optionToGet)
+        public static T SafelyGetValueForOption<T>(this ParseResult parseResult, Option<T> optionToGet)
         {
             if (parseResult.GetResult(optionToGet) is OptionResult optionResult &&
                 !parseResult.Errors.Any(e => e.SymbolResult == optionResult))
@@ -261,6 +261,6 @@ public static T SafelyGetValueForOption<T>(this ParseResult parseResult, CliOpti
             }
         }
 
-        public static bool HasOption(this ParseResult parseResult, CliOption option) => parseResult.GetResult(option) is not null;
+        public static bool HasOption(this ParseResult parseResult, Option option) => parseResult.GetResult(option) is not null;
     }
 }
diff --git a/src/Cli/dotnet/Parser.cs b/src/Cli/dotnet/Parser.cs
index 04374a3e44ea..346627215b9c 100644
--- a/src/Cli/dotnet/Parser.cs
+++ b/src/Cli/dotnet/Parser.cs
@@ -12,20 +12,21 @@
 using Microsoft.DotNet.Tools.MSBuild;
 using Microsoft.DotNet.Tools.NuGet;
 using Microsoft.TemplateEngine.Cli;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli
 {
     public static class Parser
     {
-        public static readonly CliRootCommand RootCommand = new()
+        public static readonly RootCommand RootCommand = new()
         {
             Directives = { new DiagramDirective(), new SuggestDirective(), new EnvironmentVariablesDirective() }
         };
 
-        public static readonly CliCommand InstallSuccessCommand = InternalReportinstallsuccessCommandParser.GetCommand();
+        public static readonly Command InstallSuccessCommand = InternalReportinstallsuccessCommandParser.GetCommand();
 
         // Subcommands
-        public static readonly CliCommand[] Subcommands = new CliCommand[]
+        public static readonly Command[] Subcommands = new Command[]
         {
             AddCommandParser.GetCommand(),
             BuildCommandParser.GetCommand(),
@@ -56,24 +57,24 @@ public static class Parser
             WorkloadCommandParser.GetCommand()
         };
 
-        public static readonly CliOption<bool> DiagOption = CommonOptionsFactory.CreateDiagnosticsOption(recursive: false);
+        public static readonly Option<bool> DiagOption = CommonOptionsFactory.CreateDiagnosticsOption(recursive: false);
 
-        public static readonly CliOption<bool> VersionOption = new("--version");
+        public static readonly Option<bool> VersionOption = new("--version");
 
-        public static readonly CliOption<bool> InfoOption = new("--info");
+        public static readonly Option<bool> InfoOption = new("--info");
 
-        public static readonly CliOption<bool> ListSdksOption = new("--list-sdks");
+        public static readonly Option<bool> ListSdksOption = new("--list-sdks");
 
-        public static readonly CliOption<bool> ListRuntimesOption = new("--list-runtimes");
+        public static readonly Option<bool> ListRuntimesOption = new("--list-runtimes");
 
         // Argument
-        public static readonly CliArgument<string> DotnetSubCommand = new("subcommand") { Arity = ArgumentArity.ZeroOrOne, Hidden = true };
+        public static readonly Argument<string> DotnetSubCommand = new("subcommand") { Arity = ArgumentArity.ZeroOrOne, Hidden = true };
 
-        private static CliCommand ConfigureCommandLine(CliCommand rootCommand)
+        private static Command ConfigureCommandLine(Command rootCommand)
         {
             for (int i = rootCommand.Options.Count - 1; i >= 0; i--)
             {
-                CliOption option = rootCommand.Options[i];
+                Option option = rootCommand.Options[i];
 
                 if (option is VersionOption)
                 {
@@ -125,7 +126,7 @@ private static CliCommand ConfigureCommandLine(CliCommand rootCommand)
             return rootCommand;
         }
 
-        public static CliCommand GetBuiltInCommand(string commandName)
+        public static Command GetBuiltInCommand(string commandName)
         {
             return Subcommands
                 .FirstOrDefault(c => c.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
@@ -161,7 +162,7 @@ public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>
             }
         }
 
-        public static CliConfiguration Instance { get; } = new(ConfigureCommandLine(RootCommand))
+        public static CommandLineConfiguration Instance { get; } = new(ConfigureCommandLine(RootCommand))
         {
             EnableDefaultExceptionHandler = false,
             EnablePosixBundling = false,
@@ -242,8 +243,8 @@ private static void SetHelpCustomizations(HelpBuilder builder)
             public void additionalOption(HelpContext context)
             {
                 List<TwoColumnHelpRow> options = new();
-                HashSet<CliOption> uniqueOptions = new();
-                foreach (CliOption option in context.Command.Options)
+                HashSet<Option> uniqueOptions = new();
+                foreach (Option option in context.Command.Options)
                 {
                     if (!option.Hidden && uniqueOptions.Add(option))
                     {
@@ -319,7 +320,7 @@ public override void Write(HelpContext context)
                 {
                     if (command.Name.Equals(ListProjectToProjectReferencesCommandParser.GetCommand().Name))
                     {
-                        CliCommand listCommand = command.Parents.Single() as CliCommand;
+                        Command listCommand = command.Parents.Single() as Command;
 
                         for (int i = 0; i < listCommand.Arguments.Count; i++)
                         {
diff --git a/src/Cli/dotnet/ParserExtensions.cs b/src/Cli/dotnet/ParserExtensions.cs
index bc174b7e7d60..efb8a78d83a9 100644
--- a/src/Cli/dotnet/ParserExtensions.cs
+++ b/src/Cli/dotnet/ParserExtensions.cs
@@ -8,7 +8,7 @@ namespace Microsoft.DotNet.Cli
     public static class ParserExtensions
     {
         public static ParseResult ParseFrom(
-            this CliConfiguration parser,
+            this CommandLineConfiguration parser,
             string context,
             string[] args = null) =>
             parser.Parse(context.Split(' ').Concat(args).ToArray());
diff --git a/src/Cli/dotnet/Telemetry/AllowListToSendFirstArgument.cs b/src/Cli/dotnet/Telemetry/AllowListToSendFirstArgument.cs
index de082da35866..e977063e5888 100644
--- a/src/Cli/dotnet/Telemetry/AllowListToSendFirstArgument.cs
+++ b/src/Cli/dotnet/Telemetry/AllowListToSendFirstArgument.cs
@@ -31,7 +31,7 @@ public List<ApplicationInsightsEntryFormat> AllowList(ParseResult parseResult, D
             {
                 if (_topLevelCommandNameAllowList.Contains(topLevelCommandNameFromParse))
                 {
-                    var firstArgument = parseResult.RootCommandResult.Children.FirstOrDefault()?.Tokens.Where(t => t.Type.Equals(CliTokenType.Argument)).FirstOrDefault()?.Value ?? null;
+                    var firstArgument = parseResult.RootCommandResult.Children.FirstOrDefault()?.Tokens.Where(t => t.Type.Equals(TokenType.Argument)).FirstOrDefault()?.Value ?? null;
                     if (firstArgument != null)
                     {
                         result.Add(new ApplicationInsightsEntryFormat(
diff --git a/src/Cli/dotnet/Telemetry/AllowListToSendVerbSecondVerbFirstArgument.cs b/src/Cli/dotnet/Telemetry/AllowListToSendVerbSecondVerbFirstArgument.cs
index bebf4ee42223..c8f8b8abe6f7 100644
--- a/src/Cli/dotnet/Telemetry/AllowListToSendVerbSecondVerbFirstArgument.cs
+++ b/src/Cli/dotnet/Telemetry/AllowListToSendVerbSecondVerbFirstArgument.cs
@@ -24,11 +24,11 @@ public List<ApplicationInsightsEntryFormat> AllowList(ParseResult parseResult, D
 
             if (topLevelCommandNameFromParse != null)
             {
-                var secondVerb = parseResult.Tokens.Where(s => s.Type == CliTokenType.Command).Skip(1).FirstOrDefault()?.Value ?? "";
+                var secondVerb = parseResult.Tokens.Where(s => s.Type == TokenType.Command).Skip(1).FirstOrDefault()?.Value ?? "";
 
                 if (TopLevelCommandNameAllowList.Contains(topLevelCommandNameFromParse))
                 {
-                    var firstArgument = parseResult.Tokens.FirstOrDefault(t => t.Type.Equals(CliTokenType.Argument))?.Value ?? "";
+                    var firstArgument = parseResult.Tokens.FirstOrDefault(t => t.Type.Equals(TokenType.Argument))?.Value ?? "";
                     if (secondVerb != null)
                     {
                         result.Add(new ApplicationInsightsEntryFormat(
diff --git a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
index d0990bd3652b..47b9d306c3ad 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
@@ -88,32 +88,32 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
             new TopLevelCommandNameAndOptionToLog
             (
                 topLevelCommandName: new HashSet<string> {"build", "publish"},
-                optionsToLog: new HashSet<CliOption> { BuildCommandParser.FrameworkOption, PublishCommandParser.FrameworkOption,
+                optionsToLog: new HashSet<Option> { BuildCommandParser.FrameworkOption, PublishCommandParser.FrameworkOption,
                     BuildCommandParser.RuntimeOption, PublishCommandParser.RuntimeOption, BuildCommandParser.ConfigurationOption,
                     PublishCommandParser.ConfigurationOption }
             ),
             new TopLevelCommandNameAndOptionToLog
             (
                 topLevelCommandName: new HashSet<string> {"run", "clean", "test"},
-                optionsToLog: new HashSet<CliOption> { RunCommandParser.FrameworkOption, CleanCommandParser.FrameworkOption,
+                optionsToLog: new HashSet<Option> { RunCommandParser.FrameworkOption, CleanCommandParser.FrameworkOption,
                     TestCommandParser.FrameworkOption, RunCommandParser.ConfigurationOption, CleanCommandParser.ConfigurationOption,
                     TestCommandParser.ConfigurationOption }
             ),
             new TopLevelCommandNameAndOptionToLog
             (
                 topLevelCommandName: new HashSet<string> {"pack"},
-                optionsToLog: new HashSet<CliOption> { PackCommandParser.ConfigurationOption }
+                optionsToLog: new HashSet<Option> { PackCommandParser.ConfigurationOption }
             ),
             new TopLevelCommandNameAndOptionToLog
             (
                 topLevelCommandName: new HashSet<string> {"vstest"},
-                optionsToLog: new HashSet<CliOption> { CommonOptions.TestPlatformOption,
+                optionsToLog: new HashSet<Option> { CommonOptions.TestPlatformOption,
                     CommonOptions.TestFrameworkOption, CommonOptions.TestLoggerOption }
             ),
             new TopLevelCommandNameAndOptionToLog
             (
                 topLevelCommandName: new HashSet<string> {"publish"},
-                optionsToLog: new HashSet<CliOption> { PublishCommandParser.RuntimeOption }
+                optionsToLog: new HashSet<Option> { PublishCommandParser.RuntimeOption }
             ),
             new AllowListToSendVerbSecondVerbFirstArgument(new HashSet<string> {"workload", "tool", "new"}),
         };
diff --git a/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs b/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs
index 992f07aa325f..e52fc80475de 100644
--- a/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs
+++ b/src/Cli/dotnet/Telemetry/TopLevelCommandNameAndOptionToLog.cs
@@ -12,14 +12,14 @@ internal class TopLevelCommandNameAndOptionToLog : IParseResultLogRule
     {
         public TopLevelCommandNameAndOptionToLog(
             HashSet<string> topLevelCommandName,
-            HashSet<CliOption> optionsToLog)
+            HashSet<Option> optionsToLog)
         {
             _topLevelCommandName = topLevelCommandName;
             _optionsToLog = optionsToLog;
         }
 
         private HashSet<string> _topLevelCommandName { get; }
-        private HashSet<CliOption> _optionsToLog { get; }
+        private HashSet<Option> _optionsToLog { get; }
 
         public List<ApplicationInsightsEntryFormat> AllowList(ParseResult parseResult, Dictionary<string, double> measurements = null)
         {
diff --git a/src/Cli/dotnet/commands/InstallingWorkloadCommand.cs b/src/Cli/dotnet/commands/InstallingWorkloadCommand.cs
index 8f8f2295333b..a273b3a889c1 100644
--- a/src/Cli/dotnet/commands/InstallingWorkloadCommand.cs
+++ b/src/Cli/dotnet/commands/InstallingWorkloadCommand.cs
@@ -21,6 +21,7 @@
 using Microsoft.NET.Sdk.WorkloadManifestReader;
 using NuGet.Versioning;
 using Strings = Microsoft.DotNet.Workloads.Workload.Install.LocalizableStrings;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Workloads.Workload
 {
@@ -441,63 +442,63 @@ protected IEnumerable<WorkloadId> WriteSDKInstallRecordsForVSWorkloads(IEnumerab
 
     internal static class InstallingWorkloadCommandParser
     {
-        public static readonly CliOption<string> WorkloadSetVersionOption = new("--version")
+        public static readonly Option<string> WorkloadSetVersionOption = new("--version")
         {
             Description = Strings.WorkloadSetVersionOptionDescription
         };
 
-        public static readonly CliOption<bool> PrintDownloadLinkOnlyOption = new("--print-download-link-only")
+        public static readonly Option<bool> PrintDownloadLinkOnlyOption = new("--print-download-link-only")
         {
             Description = Strings.PrintDownloadLinkOnlyDescription,
             Hidden = true
         };
 
-        public static readonly CliOption<string> FromCacheOption = new("--from-cache")
+        public static readonly Option<string> FromCacheOption = new("--from-cache")
         {
             Description = Strings.FromCacheOptionDescription,
             HelpName = Strings.FromCacheOptionArgumentName,
             Hidden = true
         };
 
-        public static readonly CliOption<bool> IncludePreviewOption =
+        public static readonly Option<bool> IncludePreviewOption =
         new("--include-previews")
         {
             Description = Strings.IncludePreviewOptionDescription
         };
 
-        public static readonly CliOption<string> DownloadToCacheOption = new("--download-to-cache")
+        public static readonly Option<string> DownloadToCacheOption = new("--download-to-cache")
         {
             Description = Strings.DownloadToCacheOptionDescription,
             HelpName = Strings.DownloadToCacheOptionArgumentName,
             Hidden = true
         };
 
-        public static readonly CliOption<string> VersionOption = new("--sdk-version")
+        public static readonly Option<string> VersionOption = new("--sdk-version")
         {
             Description = Strings.VersionOptionDescription,
             HelpName = Strings.VersionOptionName,
             Hidden = true
         };
 
-        public static readonly CliOption<string> FromRollbackFileOption = new("--from-rollback-file")
+        public static readonly Option<string> FromRollbackFileOption = new("--from-rollback-file")
         {
             Description = Update.LocalizableStrings.FromRollbackDefinitionOptionDescription,
             Hidden = true
         };
 
-        public static readonly CliOption<string> ConfigOption = new("--configfile")
+        public static readonly Option<string> ConfigOption = new("--configfile")
         {
             Description = Strings.ConfigFileOptionDescription,
             HelpName = Strings.ConfigFileOptionName
         };
 
-        public static readonly CliOption<string[]> SourceOption = new CliOption<string[]>("--source", "-s")
+        public static readonly Option<string[]> SourceOption = new Option<string[]>("--source", "-s")
         {
             Description = Strings.SourceOptionDescription,
             HelpName = Strings.SourceOptionName
         }.AllowSingleArgPerToken();
 
-        internal static void AddWorkloadInstallCommandOptions(CliCommand command)
+        internal static void AddWorkloadInstallCommandOptions(Command command)
         {
             command.Options.Add(VersionOption);
             command.Options.Add(ConfigOption);
diff --git a/src/Cli/dotnet/commands/dotnet-add/AddCommandParser.cs b/src/Cli/dotnet/commands/dotnet-add/AddCommandParser.cs
index 4739fd1c74fc..a3a176619030 100644
--- a/src/Cli/dotnet/commands/dotnet-add/AddCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-add/AddCommandParser.cs
@@ -11,19 +11,19 @@ internal static class AddCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-add";
 
-        public static readonly CliArgument<string> ProjectArgument = new CliArgument<string>(CommonLocalizableStrings.ProjectArgumentName)
+        public static readonly Argument<string> ProjectArgument = new Argument<string>(CommonLocalizableStrings.ProjectArgumentName)
         {
             Description = CommonLocalizableStrings.ProjectArgumentDescription
         }.DefaultToCurrentDirectory();
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("add", DocsLink, LocalizableStrings.NetAddCommand);
 
diff --git a/src/Cli/dotnet/commands/dotnet-add/dotnet-add-package/AddPackageParser.cs b/src/Cli/dotnet/commands/dotnet-add/dotnet-add-package/AddPackageParser.cs
index d8ee2b421303..dddca589c5f7 100644
--- a/src/Cli/dotnet/commands/dotnet-add/dotnet-add-package/AddPackageParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-add/dotnet-add-package/AddPackageParser.cs
@@ -14,7 +14,7 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class AddPackageParser
     {
-        public static readonly CliArgument<string> CmdPackageArgument = new CliArgument<string>(LocalizableStrings.CmdPackage)
+        public static readonly Argument<string> CmdPackageArgument = new Argument<string>(LocalizableStrings.CmdPackage)
         {
             Description = LocalizableStrings.CmdPackageDescription
         }.AddCompletions((context) =>
@@ -24,7 +24,7 @@ internal static class AddPackageParser
             return QueryNuGet(context.WordToComplete, allowPrerelease, CancellationToken.None).Result.Select(packageId => new CompletionItem(packageId));
         });
 
-        public static readonly CliOption<string> VersionOption = new ForwardedOption<string>("--version", "-v")
+        public static readonly Option<string> VersionOption = new ForwardedOption<string>("--version", "-v")
         {
             Description = LocalizableStrings.CmdVersionDescription,
             HelpName = LocalizableStrings.CmdVersion
@@ -46,49 +46,49 @@ internal static class AddPackageParser
                 }
             });
 
-        public static readonly CliOption<string> FrameworkOption = new ForwardedOption<string>("--framework", "-f")
+        public static readonly Option<string> FrameworkOption = new ForwardedOption<string>("--framework", "-f")
         {
             Description = LocalizableStrings.CmdFrameworkDescription,
             HelpName = LocalizableStrings.CmdFramework
         }.ForwardAsSingle(o => $"--framework {o}");
 
-        public static readonly CliOption<bool> NoRestoreOption = new("--no-restore", "-n")
+        public static readonly Option<bool> NoRestoreOption = new("--no-restore", "-n")
         {
             Description = LocalizableStrings.CmdNoRestoreDescription
         };
 
-        public static readonly CliOption<string> SourceOption = new ForwardedOption<string>("--source", "-s")
+        public static readonly Option<string> SourceOption = new ForwardedOption<string>("--source", "-s")
         {
             Description = LocalizableStrings.CmdSourceDescription,
             HelpName = LocalizableStrings.CmdSource
         }.ForwardAsSingle(o => $"--source {o}");
 
-        public static readonly CliOption<string> PackageDirOption = new ForwardedOption<string>("--package-directory")
+        public static readonly Option<string> PackageDirOption = new ForwardedOption<string>("--package-directory")
         {
             Description = LocalizableStrings.CmdPackageDirectoryDescription,
             HelpName = LocalizableStrings.CmdPackageDirectory
         }.ForwardAsSingle(o => $"--package-directory {o}");
 
-        public static readonly CliOption<bool> InteractiveOption = new ForwardedOption<bool>("--interactive")
+        public static readonly Option<bool> InteractiveOption = new ForwardedOption<bool>("--interactive")
         {
             Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
         }.ForwardAs("--interactive");
 
-        public static readonly CliOption<bool> PrereleaseOption = new ForwardedOption<bool>("--prerelease")
+        public static readonly Option<bool> PrereleaseOption = new ForwardedOption<bool>("--prerelease")
         {
             Description = CommonLocalizableStrings.CommandPrereleaseOptionDescription
         }.ForwardAs("--prerelease");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("package", LocalizableStrings.AppFullName);
+            Command command = new("package", LocalizableStrings.AppFullName);
 
             command.Arguments.Add(CmdPackageArgument);
             command.Options.Add(VersionOption);
diff --git a/src/Cli/dotnet/commands/dotnet-add/dotnet-add-reference/AddProjectToProjectReferenceParser.cs b/src/Cli/dotnet/commands/dotnet-add/dotnet-add-reference/AddProjectToProjectReferenceParser.cs
index e15a74171585..611e63c36899 100644
--- a/src/Cli/dotnet/commands/dotnet-add/dotnet-add-reference/AddProjectToProjectReferenceParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-add/dotnet-add-reference/AddProjectToProjectReferenceParser.cs
@@ -9,31 +9,31 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class AddProjectToProjectReferenceParser
     {
-        public static readonly CliArgument<IEnumerable<string>> ProjectPathArgument = new(LocalizableStrings.ProjectPathArgumentName)
+        public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new(LocalizableStrings.ProjectPathArgumentName)
         {
             Description = LocalizableStrings.ProjectPathArgumentDescription,
             Arity = ArgumentArity.OneOrMore
         };
 
-        public static readonly CliOption<string> FrameworkOption = new CliOption<string>("--framework", "-f")
+        public static readonly Option<string> FrameworkOption = new Option<string>("--framework", "-f")
         {
             Description = LocalizableStrings.CmdFrameworkDescription,
             HelpName = Tools.Add.PackageReference.LocalizableStrings.CmdFramework
 
         }.AddCompletions(Complete.TargetFrameworksFromProjectFile);
 
-        public static readonly CliOption<bool> InteractiveOption = CommonOptions.InteractiveOption;
+        public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("reference", LocalizableStrings.AppFullName);
+            Command command = new("reference", LocalizableStrings.AppFullName);
 
             command.Arguments.Add(ProjectPathArgument);
             command.Options.Add(FrameworkOption);
diff --git a/src/Cli/dotnet/commands/dotnet-build/BuildCommandParser.cs b/src/Cli/dotnet/commands/dotnet-build/BuildCommandParser.cs
index ea72e7d0bd61..60b0fc6dfffb 100644
--- a/src/Cli/dotnet/commands/dotnet-build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-build/BuildCommandParser.cs
@@ -12,50 +12,50 @@ internal static class BuildCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-build";
 
-        public static readonly CliArgument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
+        public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
         {
             Description = CommonLocalizableStrings.SolutionOrProjectArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        public static readonly CliOption<string> OutputOption = new ForwardedOption<string>("--output", "-o")
+        public static readonly Option<string> OutputOption = new ForwardedOption<string>("--output", "-o")
         {
             Description = LocalizableStrings.OutputOptionDescription,
             HelpName = LocalizableStrings.OutputOptionName
         }.ForwardAsOutputPath("OutputPath");
 
-        public static readonly CliOption<bool> NoIncrementalOption = new("--no-incremental") { Description = LocalizableStrings.NoIncrementalOptionDescription };
+        public static readonly Option<bool> NoIncrementalOption = new("--no-incremental") { Description = LocalizableStrings.NoIncrementalOptionDescription };
 
-        public static readonly CliOption<bool> NoDependenciesOption = new ForwardedOption<bool>("--no-dependencies")
+        public static readonly Option<bool> NoDependenciesOption = new ForwardedOption<bool>("--no-dependencies")
         {
             Description = LocalizableStrings.NoDependenciesOptionDescription
         }.ForwardAs("-property:BuildProjectReferences=false");
 
-        public static readonly CliOption<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
+        public static readonly Option<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
         {
             Description = LocalizableStrings.CmdNoLogo
         }.ForwardAs("-nologo");
 
-        public static readonly CliOption<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-        public static readonly CliOption<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+        public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
 
-        public static readonly CliOption<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+        public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-        public static readonly CliOption<string> RuntimeOption = CommonOptions.RuntimeOption;
+        public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption;
 
-        public static readonly CliOption<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
+        public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
 
-        public static readonly CliOption<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
+        public static readonly Option<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("build", DocsLink, LocalizableStrings.AppFullName);
 
diff --git a/src/Cli/dotnet/commands/dotnet-buildserver/BuildServerCommandParser.cs b/src/Cli/dotnet/commands/dotnet-buildserver/BuildServerCommandParser.cs
index ce249d2476db..602622881d1a 100644
--- a/src/Cli/dotnet/commands/dotnet-buildserver/BuildServerCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-buildserver/BuildServerCommandParser.cs
@@ -10,14 +10,14 @@ internal static class BuildServerCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-build-server";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("build-server", DocsLink, LocalizableStrings.CommandDescription);
 
diff --git a/src/Cli/dotnet/commands/dotnet-buildserver/shutdown/BuildServerShutdownCommandParser.cs b/src/Cli/dotnet/commands/dotnet-buildserver/shutdown/BuildServerShutdownCommandParser.cs
index ab64074a324c..d877d0e671ed 100644
--- a/src/Cli/dotnet/commands/dotnet-buildserver/shutdown/BuildServerShutdownCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-buildserver/shutdown/BuildServerShutdownCommandParser.cs
@@ -9,20 +9,20 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ServerShutdownCommandParser
     {
-        public static readonly CliOption<bool> MSBuildOption = new("--msbuild") { Description = LocalizableStrings.MSBuildOptionDescription };
-        public static readonly CliOption<bool> VbcsOption = new("--vbcscompiler") { Description = LocalizableStrings.VBCSCompilerOptionDescription };
-        public static readonly CliOption<bool> RazorOption = new("--razor") { Description = LocalizableStrings.RazorOptionDescription };
+        public static readonly Option<bool> MSBuildOption = new("--msbuild") { Description = LocalizableStrings.MSBuildOptionDescription };
+        public static readonly Option<bool> VbcsOption = new("--vbcscompiler") { Description = LocalizableStrings.VBCSCompilerOptionDescription };
+        public static readonly Option<bool> RazorOption = new("--razor") { Description = LocalizableStrings.RazorOptionDescription };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("shutdown", LocalizableStrings.CommandDescription);
+            Command command = new("shutdown", LocalizableStrings.CommandDescription);
 
             command.Options.Add(MSBuildOption);
             command.Options.Add(VbcsOption);
diff --git a/src/Cli/dotnet/commands/dotnet-clean/CleanCommandParser.cs b/src/Cli/dotnet/commands/dotnet-clean/CleanCommandParser.cs
index ffb50c4b91c6..954d252ef9ac 100644
--- a/src/Cli/dotnet/commands/dotnet-clean/CleanCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-clean/CleanCommandParser.cs
@@ -12,35 +12,35 @@ internal static class CleanCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-clean";
 
-        public static readonly CliArgument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
+        public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
         {
             Description = CommonLocalizableStrings.SolutionOrProjectArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        public static readonly CliOption<string> OutputOption = new ForwardedOption<string>("--output", "-o")
+        public static readonly Option<string> OutputOption = new ForwardedOption<string>("--output", "-o")
         {
             Description = LocalizableStrings.CmdOutputDirDescription,
             HelpName = LocalizableStrings.CmdOutputDir
         }.ForwardAsOutputPath("OutputPath");
 
-        public static readonly CliOption<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
+        public static readonly Option<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
         {
             Description = LocalizableStrings.CmdNoLogo
         }.ForwardAs("-nologo");
 
-        public static readonly CliOption FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
+        public static readonly Option FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
 
-        public static readonly CliOption ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
+        public static readonly Option ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("clean", DocsLink, LocalizableStrings.AppFullName);
 
diff --git a/src/Cli/dotnet/commands/dotnet-complete/CompleteCommandParser.cs b/src/Cli/dotnet/commands/dotnet-complete/CompleteCommandParser.cs
index 3e6265e01d76..a0add4c5e87a 100644
--- a/src/Cli/dotnet/commands/dotnet-complete/CompleteCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-complete/CompleteCommandParser.cs
@@ -7,23 +7,23 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class CompleteCommandParser
     {
-        public static readonly CliArgument<string> PathArgument = new("path");
+        public static readonly Argument<string> PathArgument = new("path");
 
-        public static readonly CliOption<int?> PositionOption = new("--position")
+        public static readonly Option<int?> PositionOption = new("--position")
         {
             HelpName = "command"
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("complete")
+            Command command = new("complete")
             {
                 Hidden = true
             };
diff --git a/src/Cli/dotnet/commands/dotnet-complete/ParseCommandParser.cs b/src/Cli/dotnet/commands/dotnet-complete/ParseCommandParser.cs
index 5daa43d97f4c..0c10fde53d07 100644
--- a/src/Cli/dotnet/commands/dotnet-complete/ParseCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-complete/ParseCommandParser.cs
@@ -7,16 +7,16 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ParseCommandParser
     {
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("parse")
+            var command = new Command("parse")
             {
                 Hidden = true
             };
diff --git a/src/Cli/dotnet/commands/dotnet-format/FormatCommandParser.cs b/src/Cli/dotnet/commands/dotnet-format/FormatCommandParser.cs
index 09a129aadda1..2249b8636b6a 100644
--- a/src/Cli/dotnet/commands/dotnet-format/FormatCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-format/FormatCommandParser.cs
@@ -8,18 +8,18 @@ namespace Microsoft.DotNet.Tools.Format
 {
     internal static partial class FormatCommandParser
     {
-        public static readonly CliArgument<string[]> Arguments = new("arguments");
+        public static readonly Argument<string[]> Arguments = new("arguments");
 
         public static readonly string DocsLink = "https://aka.ms/dotnet-format";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var formatCommand = new DocumentedCommand("format", DocsLink)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-fsi/FsiCommandParser.cs b/src/Cli/dotnet/commands/dotnet-fsi/FsiCommandParser.cs
index 4813cdbda311..3157d168d693 100644
--- a/src/Cli/dotnet/commands/dotnet-fsi/FsiCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-fsi/FsiCommandParser.cs
@@ -10,16 +10,16 @@ internal static class FsiCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-fsi";
 
-        public static readonly CliArgument<string[]> Arguments = new("arguments");
+        public static readonly Argument<string[]> Arguments = new("arguments");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("fsi", DocsLink) { Arguments };
 
diff --git a/src/Cli/dotnet/commands/dotnet-help/HelpCommandParser.cs b/src/Cli/dotnet/commands/dotnet-help/HelpCommandParser.cs
index a90111e65e0a..510f58fd1197 100644
--- a/src/Cli/dotnet/commands/dotnet-help/HelpCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-help/HelpCommandParser.cs
@@ -10,20 +10,20 @@ internal static class HelpCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-help";
 
-        public static readonly CliArgument<string[]> Argument = new(LocalizableStrings.CommandArgumentName)
+        public static readonly Argument<string[]> Argument = new(LocalizableStrings.CommandArgumentName)
         {
             Description = LocalizableStrings.CommandArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("help", DocsLink, LocalizableStrings.AppFullName);
 
diff --git a/src/Cli/dotnet/commands/dotnet-internal-reportinstallsuccess/InternalReportinstallsuccessCommandParser.cs b/src/Cli/dotnet/commands/dotnet-internal-reportinstallsuccess/InternalReportinstallsuccessCommandParser.cs
index 119d2a2035c3..20f91af17602 100644
--- a/src/Cli/dotnet/commands/dotnet-internal-reportinstallsuccess/InternalReportinstallsuccessCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-internal-reportinstallsuccess/InternalReportinstallsuccessCommandParser.cs
@@ -7,18 +7,18 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class InternalReportinstallsuccessCommandParser
     {
-        public static readonly CliArgument<string> Argument = new("internal-reportinstallsuccess-arg");
+        public static readonly Argument<string> Argument = new("internal-reportinstallsuccess-arg");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("internal-reportinstallsuccess")
+            Command command = new("internal-reportinstallsuccess")
             {
                 Hidden = true
             };
diff --git a/src/Cli/dotnet/commands/dotnet-list/ListCommandParser.cs b/src/Cli/dotnet/commands/dotnet-list/ListCommandParser.cs
index 58bd724308d8..e42038f895d0 100644
--- a/src/Cli/dotnet/commands/dotnet-list/ListCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-list/ListCommandParser.cs
@@ -11,23 +11,23 @@ internal static class ListCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-list";
 
-        public static readonly CliArgument<string> SlnOrProjectArgument = CreateSlnOrProjectArgument(CommonLocalizableStrings.SolutionOrProjectArgumentName, CommonLocalizableStrings.SolutionOrProjectArgumentDescription);
+        public static readonly Argument<string> SlnOrProjectArgument = CreateSlnOrProjectArgument(CommonLocalizableStrings.SolutionOrProjectArgumentName, CommonLocalizableStrings.SolutionOrProjectArgumentDescription);
 
-        internal static CliArgument<string> CreateSlnOrProjectArgument(string name, string description)
-            => new CliArgument<string>(name)
+        internal static Argument<string> CreateSlnOrProjectArgument(string name, string description)
+            => new Argument<string>(name)
             {
                 Description = description,
                 Arity = ArgumentArity.ZeroOrOne
             }.DefaultToCurrentDirectory();
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("list", DocsLink, LocalizableStrings.NetListCommand);
 
diff --git a/src/Cli/dotnet/commands/dotnet-list/dotnet-list-package/ListPackageReferencesCommandParser.cs b/src/Cli/dotnet/commands/dotnet-list/dotnet-list-package/ListPackageReferencesCommandParser.cs
index d26e460cb14d..aa7e81dc1662 100644
--- a/src/Cli/dotnet/commands/dotnet-list/dotnet-list-package/ListPackageReferencesCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-list/dotnet-list-package/ListPackageReferencesCommandParser.cs
@@ -10,92 +10,92 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ListPackageReferencesCommandParser
     {
-        public static readonly CliOption OutdatedOption = new ForwardedOption<bool>("--outdated")
+        public static readonly Option OutdatedOption = new ForwardedOption<bool>("--outdated")
         {
             Description = LocalizableStrings.CmdOutdatedDescription
         }.ForwardAs("--outdated");
 
-        public static readonly CliOption DeprecatedOption = new ForwardedOption<bool>("--deprecated")
+        public static readonly Option DeprecatedOption = new ForwardedOption<bool>("--deprecated")
         {
             Description = LocalizableStrings.CmdDeprecatedDescription
         }.ForwardAs("--deprecated");
 
-        public static readonly CliOption VulnerableOption = new ForwardedOption<bool>("--vulnerable")
+        public static readonly Option VulnerableOption = new ForwardedOption<bool>("--vulnerable")
         {
             Description = LocalizableStrings.CmdVulnerableDescription
         }.ForwardAs("--vulnerable");
 
-        public static readonly CliOption FrameworkOption = new ForwardedOption<IEnumerable<string>>("--framework", "-f")
+        public static readonly Option FrameworkOption = new ForwardedOption<IEnumerable<string>>("--framework", "-f")
         {
             Description = LocalizableStrings.CmdFrameworkDescription,
             HelpName = LocalizableStrings.CmdFramework
         }.ForwardAsManyArgumentsEachPrefixedByOption("--framework")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption TransitiveOption = new ForwardedOption<bool>("--include-transitive")
+        public static readonly Option TransitiveOption = new ForwardedOption<bool>("--include-transitive")
         {
             Description = LocalizableStrings.CmdTransitiveDescription
         }.ForwardAs("--include-transitive");
 
-        public static readonly CliOption PrereleaseOption = new ForwardedOption<bool>("--include-prerelease")
+        public static readonly Option PrereleaseOption = new ForwardedOption<bool>("--include-prerelease")
         {
             Description = LocalizableStrings.CmdPrereleaseDescription
         }.ForwardAs("--include-prerelease");
 
-        public static readonly CliOption HighestPatchOption = new ForwardedOption<bool>("--highest-patch")
+        public static readonly Option HighestPatchOption = new ForwardedOption<bool>("--highest-patch")
         {
             Description = LocalizableStrings.CmdHighestPatchDescription
         }.ForwardAs("--highest-patch");
 
-        public static readonly CliOption HighestMinorOption = new ForwardedOption<bool>("--highest-minor")
+        public static readonly Option HighestMinorOption = new ForwardedOption<bool>("--highest-minor")
         {
             Description = LocalizableStrings.CmdHighestMinorDescription
         }.ForwardAs("--highest-minor");
 
-        public static readonly CliOption ConfigOption = new ForwardedOption<string>("--config", "--configfile")
+        public static readonly Option ConfigOption = new ForwardedOption<string>("--config", "--configfile")
         {
             Description = LocalizableStrings.CmdConfigDescription,
             HelpName = LocalizableStrings.CmdConfig
         }.ForwardAsMany(o => new[] { "--config", o });
 
-        public static readonly CliOption SourceOption = new ForwardedOption<IEnumerable<string>>("--source", "-s")
+        public static readonly Option SourceOption = new ForwardedOption<IEnumerable<string>>("--source", "-s")
         {
             Description = LocalizableStrings.CmdSourceDescription,
             HelpName = LocalizableStrings.CmdSource
         }.ForwardAsManyArgumentsEachPrefixedByOption("--source")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption InteractiveOption = new ForwardedOption<bool>("--interactive")
+        public static readonly Option InteractiveOption = new ForwardedOption<bool>("--interactive")
         {
             Description = CommonLocalizableStrings.CommandInteractiveOptionDescription
         }.ForwardAs("--interactive");
 
-        public static readonly CliOption VerbosityOption = new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
+        public static readonly Option VerbosityOption = new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
         {
             Description = CommonLocalizableStrings.VerbosityOptionDescription,
             HelpName = CommonLocalizableStrings.LevelArgumentName
         }.ForwardAsSingle(o => $"--verbosity:{o}");
 
-        public static readonly CliOption FormatOption = new ForwardedOption<ReportOutputFormat>("--format")
+        public static readonly Option FormatOption = new ForwardedOption<ReportOutputFormat>("--format")
         {
             Description = LocalizableStrings.CmdFormatDescription
         }.ForwardAsSingle(o => $"--format:{o}");
 
-        public static readonly CliOption OutputVersionOption = new ForwardedOption<int>("--output-version")
+        public static readonly Option OutputVersionOption = new ForwardedOption<int>("--output-version")
         {
             Description = LocalizableStrings.CmdOutputVersionDescription
         }.ForwardAsSingle(o => $"--output-version:{o}");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("package", LocalizableStrings.AppFullName);
+            Command command = new("package", LocalizableStrings.AppFullName);
 
             command.Options.Add(VerbosityOption);
             command.Options.Add(OutdatedOption);
diff --git a/src/Cli/dotnet/commands/dotnet-list/dotnet-list-reference/ListProjectToProjectReferencesCommandParser.cs b/src/Cli/dotnet/commands/dotnet-list/dotnet-list-reference/ListProjectToProjectReferencesCommandParser.cs
index c98a044dfced..8477db2cd758 100644
--- a/src/Cli/dotnet/commands/dotnet-list/dotnet-list-reference/ListProjectToProjectReferencesCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-list/dotnet-list-reference/ListProjectToProjectReferencesCommandParser.cs
@@ -9,18 +9,18 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ListProjectToProjectReferencesCommandParser
     {
-        public static readonly CliArgument<string> Argument = new("argument") { Arity = ArgumentArity.ZeroOrOne, Hidden = true };
+        public static readonly Argument<string> Argument = new("argument") { Arity = ArgumentArity.ZeroOrOne, Hidden = true };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("reference", LocalizableStrings.AppFullName);
+            var command = new Command("reference", LocalizableStrings.AppFullName);
 
             command.Arguments.Add(Argument);
 
diff --git a/src/Cli/dotnet/commands/dotnet-msbuild/MSBuildCommandParser.cs b/src/Cli/dotnet/commands/dotnet-msbuild/MSBuildCommandParser.cs
index 4efe97e004c0..829fc5176836 100644
--- a/src/Cli/dotnet/commands/dotnet-msbuild/MSBuildCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-msbuild/MSBuildCommandParser.cs
@@ -11,16 +11,16 @@ internal static class MSBuildCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-msbuild";
 
-        public static readonly CliArgument<string[]> Arguments = new("arguments");
+        public static readonly Argument<string[]> Arguments = new("arguments");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("msbuild", DocsLink, LocalizableStrings.AppFullName)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-new/NewCommandParser.cs b/src/Cli/dotnet/commands/dotnet-new/NewCommandParser.cs
index 0f9955f71f4e..54e69f53c849 100644
--- a/src/Cli/dotnet/commands/dotnet-new/NewCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-new/NewCommandParser.cs
@@ -18,6 +18,7 @@
 using Microsoft.TemplateEngine.Cli.PostActionProcessors;
 using Microsoft.TemplateEngine.MSBuildEvaluation;
 using LocalizableStrings = Microsoft.DotNet.Tools.New.LocalizableStrings;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -32,14 +33,14 @@ internal static class NewCommandParser
 
         private const VerbosityOptions DefaultVerbosity = VerbosityOptions.normal;
 
-        private static readonly CliOption<bool> s_disableSdkTemplatesOption = new CliOption<bool>("--debug:disable-sdk-templates")
+        private static readonly Option<bool> s_disableSdkTemplatesOption = new Option<bool>("--debug:disable-sdk-templates")
         {
             DefaultValueFactory = static _ => false,
             Description = LocalizableStrings.DisableSdkTemplates_OptionDescription,
             Recursive = true
         }.Hide();
 
-        private static readonly CliOption<bool> s_disableProjectContextEvaluationOption = new CliOption<bool>(
+        private static readonly Option<bool> s_disableProjectContextEvaluationOption = new Option<bool>(
             "--debug:disable-project-context")
         {
             DefaultValueFactory = static _ => false,
@@ -47,7 +48,7 @@ internal static class NewCommandParser
             Recursive = true
         }.Hide();
 
-        private static readonly CliOption<VerbosityOptions> s_verbosityOption = new("--verbosity", "-v")
+        private static readonly Option<VerbosityOptions> s_verbosityOption = new("--verbosity", "-v")
         {
             DefaultValueFactory = _ => DefaultVerbosity,
             Description = LocalizableStrings.Verbosity_OptionDescription,
@@ -55,16 +56,16 @@ internal static class NewCommandParser
             Recursive = true
         };
 
-        private static readonly CliOption<bool> s_diagnosticOption =
+        private static readonly Option<bool> s_diagnosticOption =
             CommonOptionsFactory
                 .CreateDiagnosticsOption(recursive: true)
                 .WithDescription(LocalizableStrings.Diagnostics_OptionDescription);
 
-        internal static readonly CliCommand s_command = GetCommand();
+        internal static readonly Command s_command = GetCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
-            CliCommand command = NewCommandFactory.Create(CommandName, (Func<ParseResult, CliTemplateEngineHost>)GetEngineHost);
+            Command command = NewCommandFactory.Create(CommandName, (Func<ParseResult, CliTemplateEngineHost>)GetEngineHost);
             command.Options.Add(s_disableSdkTemplatesOption);
             command.Options.Add(s_disableProjectContextEvaluationOption);
             command.Options.Add(s_verbosityOption);
diff --git a/src/Cli/dotnet/commands/dotnet-nuget/NuGetCommandParser.cs b/src/Cli/dotnet/commands/dotnet-nuget/NuGetCommandParser.cs
index 1909c2fad5ba..4d818cb7d291 100644
--- a/src/Cli/dotnet/commands/dotnet-nuget/NuGetCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-nuget/NuGetCommandParser.cs
@@ -12,14 +12,14 @@ internal static class NuGetCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-nuget";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("nuget", DocsLink)
             {
@@ -27,8 +27,8 @@ private static CliCommand ConstructCommand()
                 TreatUnmatchedTokensAsErrors = false
             };
 
-            command.Options.Add(new CliOption<bool>("--version"));
-            command.Options.Add(new CliOption<string>("--verbosity", "-v"));
+            command.Options.Add(new Option<bool>("--version"));
+            command.Options.Add(new Option<string>("--verbosity", "-v"));
 
             command.Subcommands.Add(GetDeleteCommand());
             command.Subcommands.Add(GetLocalsCommand());
@@ -43,71 +43,71 @@ private static CliCommand ConstructCommand()
             return command;
         }
 
-        private static CliCommand GetDeleteCommand()
+        private static Command GetDeleteCommand()
         {
-            CliCommand deleteCommand = new("delete");
-            deleteCommand.Arguments.Add(new CliArgument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-            deleteCommand.Options.Add(new CliOption<bool>("--force-english-output"));
-            deleteCommand.Options.Add(new CliOption<string>("--source", "-s"));
-            deleteCommand.Options.Add(new CliOption<bool>("--non-interactive"));
-            deleteCommand.Options.Add(new CliOption<string>("--api-key", "-k"));
-            deleteCommand.Options.Add(new CliOption<bool>("--no-service-endpoint"));
-            deleteCommand.Options.Add(new CliOption<bool>("--interactive"));
+            Command deleteCommand = new("delete");
+            deleteCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+            deleteCommand.Options.Add(new Option<bool>("--force-english-output"));
+            deleteCommand.Options.Add(new Option<string>("--source", "-s"));
+            deleteCommand.Options.Add(new Option<bool>("--non-interactive"));
+            deleteCommand.Options.Add(new Option<string>("--api-key", "-k"));
+            deleteCommand.Options.Add(new Option<bool>("--no-service-endpoint"));
+            deleteCommand.Options.Add(new Option<bool>("--interactive"));
 
             deleteCommand.SetAction(NuGetCommand.Run);
 
             return deleteCommand;
         }
 
-        private static CliCommand GetLocalsCommand()
+        private static Command GetLocalsCommand()
         {
-            CliCommand localsCommand = new("locals");
+            Command localsCommand = new("locals");
 
-            CliArgument<string> foldersArgument = new("folders");
+            Argument<string> foldersArgument = new("folders");
             foldersArgument.AcceptOnlyFromAmong(new string[] { "all", "http-cache", "global-packages", "plugins-cache", "temp" });
 
             localsCommand.Arguments.Add(foldersArgument);
 
-            localsCommand.Options.Add(new CliOption<bool>("--force-english-output"));
-            localsCommand.Options.Add(new CliOption<bool>("--clear", "-c"));
-            localsCommand.Options.Add(new CliOption<bool>("--list", "-l"));
+            localsCommand.Options.Add(new Option<bool>("--force-english-output"));
+            localsCommand.Options.Add(new Option<bool>("--clear", "-c"));
+            localsCommand.Options.Add(new Option<bool>("--list", "-l"));
 
             localsCommand.SetAction(NuGetCommand.Run);
 
             return localsCommand;
         }
 
-        private static CliCommand GetPushCommand()
+        private static Command GetPushCommand()
         {
-            CliCommand pushCommand = new("push");
-
-            pushCommand.Arguments.Add(new CliArgument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-
-            pushCommand.Options.Add(new CliOption<bool>("--force-english-output"));
-            pushCommand.Options.Add(new CliOption<string>("--source", "-s"));
-            pushCommand.Options.Add(new CliOption<string>("--symbol-source", "-ss"));
-            pushCommand.Options.Add(new CliOption<string>("--timeout", "-t"));
-            pushCommand.Options.Add(new CliOption<string>("--api-key", "-k"));
-            pushCommand.Options.Add(new CliOption<string>("--symbol-api-key", "-sk"));
-            pushCommand.Options.Add(new CliOption<bool>("--disable-buffering", "-d"));
-            pushCommand.Options.Add(new CliOption<bool>("--no-symbols", "-n"));
-            pushCommand.Options.Add(new CliOption<bool>("--no-service-endpoint"));
-            pushCommand.Options.Add(new CliOption<bool>("--interactive"));
-            pushCommand.Options.Add(new CliOption<bool>("--skip-duplicate"));
+            Command pushCommand = new("push");
+
+            pushCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+
+            pushCommand.Options.Add(new Option<bool>("--force-english-output"));
+            pushCommand.Options.Add(new Option<string>("--source", "-s"));
+            pushCommand.Options.Add(new Option<string>("--symbol-source", "-ss"));
+            pushCommand.Options.Add(new Option<string>("--timeout", "-t"));
+            pushCommand.Options.Add(new Option<string>("--api-key", "-k"));
+            pushCommand.Options.Add(new Option<string>("--symbol-api-key", "-sk"));
+            pushCommand.Options.Add(new Option<bool>("--disable-buffering", "-d"));
+            pushCommand.Options.Add(new Option<bool>("--no-symbols", "-n"));
+            pushCommand.Options.Add(new Option<bool>("--no-service-endpoint"));
+            pushCommand.Options.Add(new Option<bool>("--interactive"));
+            pushCommand.Options.Add(new Option<bool>("--skip-duplicate"));
 
             pushCommand.SetAction(NuGetCommand.Run);
 
             return pushCommand;
         }
 
-        private static CliCommand GetVerifyCommand()
+        private static Command GetVerifyCommand()
         {
             const string fingerprint = "--certificate-fingerprint";
-            CliCommand verifyCommand = new("verify");
+            Command verifyCommand = new("verify");
 
-            verifyCommand.Arguments.Add(new CliArgument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+            verifyCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
 
-            verifyCommand.Options.Add(new CliOption<bool>("--all"));
+            verifyCommand.Options.Add(new Option<bool>("--all"));
             verifyCommand.Options.Add(new ForwardedOption<IEnumerable<string>>(fingerprint)
                 .ForwardAsManyArgumentsEachPrefixedByOption(fingerprint)
                 .AllowSingleArgPerToken());
@@ -118,14 +118,14 @@ private static CliCommand GetVerifyCommand()
             return verifyCommand;
         }
 
-        private static CliCommand GetTrustCommand()
+        private static Command GetTrustCommand()
         {
-            CliCommand trustCommand = new("trust");
+            Command trustCommand = new("trust");
 
-            CliOption<bool> allowUntrustedRoot = new("--allow-untrusted-root");
-            CliOption<string> owners = new("--owners");
+            Option<bool> allowUntrustedRoot = new("--allow-untrusted-root");
+            Option<string> owners = new("--owners");
 
-            trustCommand.Subcommands.Add(new CliCommand("list"));
+            trustCommand.Subcommands.Add(new Command("list"));
             trustCommand.Subcommands.Add(AuthorCommand());
             trustCommand.Subcommands.Add(RepositoryCommand());
             trustCommand.Subcommands.Add(SourceCommand());
@@ -133,7 +133,7 @@ private static CliCommand GetTrustCommand()
             trustCommand.Subcommands.Add(RemoveCommand());
             trustCommand.Subcommands.Add(SyncCommand());
 
-            CliOption<string> configFile = new("--configfile");
+            Option<string> configFile = new("--configfile");
 
             // now set global options for all nuget commands: configfile, verbosity
             // as well as the standard NugetCommand.Run handler
@@ -149,69 +149,69 @@ private static CliCommand GetTrustCommand()
                 command.SetAction(NuGetCommand.Run);
             }
 
-            CliCommand AuthorCommand() => new("author") {
-                new CliArgument<string>("NAME"),
-                new CliArgument<string>("PACKAGE"),
+            Command AuthorCommand() => new("author") {
+                new Argument<string>("NAME"),
+                new Argument<string>("PACKAGE"),
                 allowUntrustedRoot,
             };
 
-            CliCommand RepositoryCommand() => new("repository") {
-                new CliArgument<string>("NAME"),
-                new CliArgument<string>("PACKAGE"),
+            Command RepositoryCommand() => new("repository") {
+                new Argument<string>("NAME"),
+                new Argument<string>("PACKAGE"),
                 allowUntrustedRoot,
                 owners
             };
 
-            CliCommand SourceCommand() => new("source") {
-                new CliArgument<string>("NAME"),
+            Command SourceCommand() => new("source") {
+                new Argument<string>("NAME"),
                 owners,
-                new CliOption<string>("--source-url"),
+                new Option<string>("--source-url"),
             };
 
-            CliCommand CertificateCommand()
+            Command CertificateCommand()
             {
-                CliOption<string> algorithm = new("--algorithm")
+                Option<string> algorithm = new("--algorithm")
                 {
                     DefaultValueFactory = (_argResult) => "SHA256"
                 };
                 algorithm.AcceptOnlyFromAmong("SHA256", "SHA384", "SHA512");
 
-                return new CliCommand("certificate") {
-                    new CliArgument<string>("NAME"),
-                    new CliArgument<string>("FINGERPRINT"),
+                return new Command("certificate") {
+                    new Argument<string>("NAME"),
+                    new Argument<string>("FINGERPRINT"),
                     allowUntrustedRoot,
                     algorithm
                 };
             };
 
-            CliCommand RemoveCommand() => new("remove") {
-                new CliArgument<string>("NAME"),
+            Command RemoveCommand() => new("remove") {
+                new Argument<string>("NAME"),
             };
 
-            CliCommand SyncCommand() => new("sync") {
-                new CliArgument<string>("NAME"),
+            Command SyncCommand() => new("sync") {
+                new Argument<string>("NAME"),
             };
 
             return trustCommand;
         }
 
-        private static CliCommand GetSignCommand()
+        private static Command GetSignCommand()
         {
-            CliCommand signCommand = new("sign");
-
-            signCommand.Arguments.Add(new CliArgument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-
-            signCommand.Options.Add(new CliOption<string>("--output", "-o"));
-            signCommand.Options.Add(new CliOption<string>("--certificate-path"));
-            signCommand.Options.Add(new CliOption<string>("--certificate-store-name"));
-            signCommand.Options.Add(new CliOption<string>("--certificate-store-location"));
-            signCommand.Options.Add(new CliOption<string>("--certificate-subject-name"));
-            signCommand.Options.Add(new CliOption<string>("--certificate-fingerprint"));
-            signCommand.Options.Add(new CliOption<string>("--certificate-password"));
-            signCommand.Options.Add(new CliOption<string>("--hash-algorithm"));
-            signCommand.Options.Add(new CliOption<string>("--timestamper"));
-            signCommand.Options.Add(new CliOption<string>("--timestamp-hash-algorithm"));
-            signCommand.Options.Add(new CliOption<bool>("--overwrite"));
+            Command signCommand = new("sign");
+
+            signCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+
+            signCommand.Options.Add(new Option<string>("--output", "-o"));
+            signCommand.Options.Add(new Option<string>("--certificate-path"));
+            signCommand.Options.Add(new Option<string>("--certificate-store-name"));
+            signCommand.Options.Add(new Option<string>("--certificate-store-location"));
+            signCommand.Options.Add(new Option<string>("--certificate-subject-name"));
+            signCommand.Options.Add(new Option<string>("--certificate-fingerprint"));
+            signCommand.Options.Add(new Option<string>("--certificate-password"));
+            signCommand.Options.Add(new Option<string>("--hash-algorithm"));
+            signCommand.Options.Add(new Option<string>("--timestamper"));
+            signCommand.Options.Add(new Option<string>("--timestamp-hash-algorithm"));
+            signCommand.Options.Add(new Option<bool>("--overwrite"));
             signCommand.Options.Add(CommonOptions.VerbosityOption);
 
             signCommand.SetAction(NuGetCommand.Run);
diff --git a/src/Cli/dotnet/commands/dotnet-pack/PackCommandParser.cs b/src/Cli/dotnet/commands/dotnet-pack/PackCommandParser.cs
index 679e23c7a77e..4143d774de38 100644
--- a/src/Cli/dotnet/commands/dotnet-pack/PackCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-pack/PackCommandParser.cs
@@ -12,55 +12,55 @@ internal static class PackCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-pack";
 
-        public static readonly CliArgument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
+        public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
         {
             Description = CommonLocalizableStrings.SolutionOrProjectArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        public static readonly CliOption<string> OutputOption = new ForwardedOption<string>("--output", "-o")
+        public static readonly Option<string> OutputOption = new ForwardedOption<string>("--output", "-o")
         {
             Description = LocalizableStrings.CmdOutputDirDescription,
             HelpName = LocalizableStrings.CmdOutputDir
         }.ForwardAsSingle(o => $"-property:PackageOutputPath={CommandDirectoryContext.GetFullPath(o)}");
 
-        public static readonly CliOption<bool> NoBuildOption = new ForwardedOption<bool>("--no-build")
+        public static readonly Option<bool> NoBuildOption = new ForwardedOption<bool>("--no-build")
         {
             Description = LocalizableStrings.CmdNoBuildOptionDescription
         }.ForwardAs("-property:NoBuild=true");
 
-        public static readonly CliOption<bool> IncludeSymbolsOption = new ForwardedOption<bool>("--include-symbols")
+        public static readonly Option<bool> IncludeSymbolsOption = new ForwardedOption<bool>("--include-symbols")
         {
             Description = LocalizableStrings.CmdIncludeSymbolsDescription
         }.ForwardAs("-property:IncludeSymbols=true");
 
-        public static readonly CliOption<bool> IncludeSourceOption = new ForwardedOption<bool>("--include-source")
+        public static readonly Option<bool> IncludeSourceOption = new ForwardedOption<bool>("--include-source")
         {
             Description = LocalizableStrings.CmdIncludeSourceDescription
         }.ForwardAs("-property:IncludeSource=true");
 
-        public static readonly CliOption<bool> ServiceableOption = new ForwardedOption<bool>("--serviceable", "-s")
+        public static readonly Option<bool> ServiceableOption = new ForwardedOption<bool>("--serviceable", "-s")
         {
             Description = LocalizableStrings.CmdServiceableDescription
         }.ForwardAs("-property:Serviceable=true");
 
-        public static readonly CliOption<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
+        public static readonly Option<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
         {
             Description = LocalizableStrings.CmdNoLogo
         }.ForwardAs("-nologo");
 
-        public static readonly CliOption<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-        public static readonly CliOption<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
+        public static readonly Option<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("pack", DocsLink, LocalizableStrings.AppFullName);
 
diff --git a/src/Cli/dotnet/commands/dotnet-package/PackageCommandParser.cs b/src/Cli/dotnet/commands/dotnet-package/PackageCommandParser.cs
index 63bf74e8faa3..09527d0d09b1 100644
--- a/src/Cli/dotnet/commands/dotnet-package/PackageCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-package/PackageCommandParser.cs
@@ -9,9 +9,9 @@ internal class PackageCommandParser
     {
         private const string DocsLink = "https://aka.ms/dotnet-package";
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
-            CliCommand command = new DocumentedCommand("package", DocsLink);
+            Command command = new DocumentedCommand("package", DocsLink);
             command.SetAction((parseResult) => parseResult.HandleMissingCommand());
             command.Subcommands.Add(PackageSearchCommandParser.GetCommand());
 
diff --git a/src/Cli/dotnet/commands/dotnet-package/search/PackageSearchCommandParser.cs b/src/Cli/dotnet/commands/dotnet-package/search/PackageSearchCommandParser.cs
index 7b56396fe9cb..99f4ab568a06 100644
--- a/src/Cli/dotnet/commands/dotnet-package/search/PackageSearchCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-package/search/PackageSearchCommandParser.cs
@@ -8,75 +8,75 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class PackageSearchCommandParser
     {
-        public static readonly CliArgument<string> SearchTermArgument = new CliArgument<string>("SearchTerm")
+        public static readonly Argument<string> SearchTermArgument = new Argument<string>("SearchTerm")
         {
             HelpName = LocalizableStrings.SearchTermArgumentName,
             Description = LocalizableStrings.SearchTermDescription,
             Arity = ArgumentArity.ZeroOrOne
         };
 
-        public static readonly CliOption Sources =  new ForwardedOption<IEnumerable<string>>("--source")
+        public static readonly Option Sources =  new ForwardedOption<IEnumerable<string>>("--source")
         {
             Description = LocalizableStrings.SourceDescription,
             HelpName = LocalizableStrings.SourceArgumentName
         }.ForwardAsManyArgumentsEachPrefixedByOption("--source")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption<string> Take = new ForwardedOption<string>("--take")
+        public static readonly Option<string> Take = new ForwardedOption<string>("--take")
         {
             Description = LocalizableStrings.TakeDescription,
             HelpName = LocalizableStrings.TakeArgumentName
         }.ForwardAsSingle(o => $"--take:{o}");
 
-        public static readonly CliOption<string> Skip = new ForwardedOption<string>("--skip")
+        public static readonly Option<string> Skip = new ForwardedOption<string>("--skip")
         {
             Description = LocalizableStrings.SkipDescription,
             HelpName = LocalizableStrings.SkipArgumentName
         }.ForwardAsSingle(o => $"--skip:{o}");
 
-        public static readonly CliOption<bool> ExactMatch = new ForwardedOption<bool>("--exact-match")
+        public static readonly Option<bool> ExactMatch = new ForwardedOption<bool>("--exact-match")
         {
             Description = LocalizableStrings.ExactMatchDescription
         }.ForwardAs("--exact-match");
 
-        public static readonly CliOption<bool> Interactive = new ForwardedOption<bool>("--interactive")
+        public static readonly Option<bool> Interactive = new ForwardedOption<bool>("--interactive")
         {
             Description = LocalizableStrings.InteractiveDescription
         }.ForwardAs("--interactive");
 
-        public static readonly CliOption<bool> Prerelease = new ForwardedOption<bool>("--prerelease")
+        public static readonly Option<bool> Prerelease = new ForwardedOption<bool>("--prerelease")
         {
             Description = LocalizableStrings.PrereleaseDescription
         }.ForwardAs("--prerelease");
 
-        public static readonly CliOption<string> ConfigFile = new ForwardedOption<string>("--configfile")
+        public static readonly Option<string> ConfigFile = new ForwardedOption<string>("--configfile")
         {
             Description = LocalizableStrings.ConfigFileDescription,
             HelpName = LocalizableStrings.ConfigFileArgumentName
         }.ForwardAsSingle(o => $"--configfile:{o}");
 
-        public static readonly CliOption<string> Format = new ForwardedOption<string>("--format")
+        public static readonly Option<string> Format = new ForwardedOption<string>("--format")
         {
             Description = LocalizableStrings.FormatDescription,
             HelpName = LocalizableStrings.FormatArgumentName
         }.ForwardAsSingle(o => $"--format:{o}");
 
-        public static readonly CliOption<string> Verbosity = new ForwardedOption<string>("--verbosity")
+        public static readonly Option<string> Verbosity = new ForwardedOption<string>("--verbosity")
         {
             Description = LocalizableStrings.VerbosityDescription,
             HelpName = LocalizableStrings.VerbosityArgumentName
         }.ForwardAsSingle(o => $"--verbosity:{o}");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand searchCommand = new("search", LocalizableStrings.CommandDescription);
+            Command searchCommand = new("search", LocalizableStrings.CommandDescription);
 
             searchCommand.Arguments.Add(SearchTermArgument);
             searchCommand.Options.Add(Sources);
diff --git a/src/Cli/dotnet/commands/dotnet-publish/PublishCommandParser.cs b/src/Cli/dotnet/commands/dotnet-publish/PublishCommandParser.cs
index eb8c0b66652f..df399acd0e35 100644
--- a/src/Cli/dotnet/commands/dotnet-publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-publish/PublishCommandParser.cs
@@ -12,55 +12,55 @@ internal static class PublishCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-publish";
 
-        public static readonly CliArgument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
+        public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
         {
             Description = CommonLocalizableStrings.SolutionOrProjectArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        public static readonly CliOption<string> OutputOption = new ForwardedOption<string>("--output", "-o")
+        public static readonly Option<string> OutputOption = new ForwardedOption<string>("--output", "-o")
         {
             Description = LocalizableStrings.OutputOptionDescription,
             HelpName = LocalizableStrings.OutputOption
         }.ForwardAsOutputPath("PublishDir");
 
-        public static readonly CliOption<IEnumerable<string>> ManifestOption = new ForwardedOption<IEnumerable<string>>("--manifest")
+        public static readonly Option<IEnumerable<string>> ManifestOption = new ForwardedOption<IEnumerable<string>>("--manifest")
         {
             Description = LocalizableStrings.ManifestOptionDescription,
             HelpName = LocalizableStrings.ManifestOption
         }.ForwardAsSingle(o => $"-property:TargetManifestFiles={string.Join("%3B", o.Select(CommandDirectoryContext.GetFullPath))}")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption<bool> NoBuildOption = new ForwardedOption<bool>("--no-build")
+        public static readonly Option<bool> NoBuildOption = new ForwardedOption<bool>("--no-build")
         {
             Description = LocalizableStrings.NoBuildOptionDescription
         }.ForwardAs("-property:NoBuild=true");
 
-        public static readonly CliOption<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
+        public static readonly Option<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
         {
             Description = LocalizableStrings.CmdNoLogo
         }.ForwardAs("-nologo");
 
-        public static readonly CliOption<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-        public static readonly CliOption<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+        public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
 
-        public static readonly CliOption<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+        public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-        public static readonly CliOption<string> RuntimeOption = CommonOptions.RuntimeOption;
+        public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption;
 
-        public static readonly CliOption<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
+        public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
 
-        public static readonly CliOption<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
+        public static readonly Option<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("publish", DocsLink, LocalizableStrings.AppDescription);
 
diff --git a/src/Cli/dotnet/commands/dotnet-remove/RemoveCommandParser.cs b/src/Cli/dotnet/commands/dotnet-remove/RemoveCommandParser.cs
index 37f94319e170..737e9f0f0503 100644
--- a/src/Cli/dotnet/commands/dotnet-remove/RemoveCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-remove/RemoveCommandParser.cs
@@ -11,19 +11,19 @@ internal static class RemoveCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-remove";
 
-        public static readonly CliArgument<string> ProjectArgument = new CliArgument<string>(CommonLocalizableStrings.ProjectArgumentName)
+        public static readonly Argument<string> ProjectArgument = new Argument<string>(CommonLocalizableStrings.ProjectArgumentName)
         {
             Description = CommonLocalizableStrings.ProjectArgumentDescription
         }.DefaultToCurrentDirectory();
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("remove", DocsLink, LocalizableStrings.NetRemoveCommand);
 
diff --git a/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-package/RemovePackageParser.cs b/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-package/RemovePackageParser.cs
index e12e156a4f0d..8eee9108d716 100644
--- a/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-package/RemovePackageParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-package/RemovePackageParser.cs
@@ -10,27 +10,27 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class RemovePackageParser
     {
-        public static readonly CliArgument<IEnumerable<string>> CmdPackageArgument = new(Tools.Add.PackageReference.LocalizableStrings.CmdPackage)
+        public static readonly Argument<IEnumerable<string>> CmdPackageArgument = new(Tools.Add.PackageReference.LocalizableStrings.CmdPackage)
         {
             Description = LocalizableStrings.AppHelpText,
             Arity = ArgumentArity.OneOrMore,
         };
 
-        public static readonly CliOption<bool> InteractiveOption = new ForwardedOption<bool>("--interactive")
+        public static readonly Option<bool> InteractiveOption = new ForwardedOption<bool>("--interactive")
         {
             Description = CommonLocalizableStrings.CommandInteractiveOptionDescription
         }.ForwardAs("--interactive");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("package", LocalizableStrings.AppFullName);
+            var command = new Command("package", LocalizableStrings.AppFullName);
 
             command.Arguments.Add(CmdPackageArgument);
             command.Options.Add(InteractiveOption);
diff --git a/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-reference/RemoveProjectToProjectReferenceParser.cs b/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-reference/RemoveProjectToProjectReferenceParser.cs
index 9a19eaf88a2f..5f36eab74b87 100644
--- a/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-reference/RemoveProjectToProjectReferenceParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-remove/dotnet-remove-reference/RemoveProjectToProjectReferenceParser.cs
@@ -10,28 +10,28 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class RemoveProjectToProjectReferenceParser
     {
-        public static readonly CliArgument<IEnumerable<string>> ProjectPathArgument = new CliArgument<IEnumerable<string>>(LocalizableStrings.ProjectPathArgumentName)
+        public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new Argument<IEnumerable<string>>(LocalizableStrings.ProjectPathArgumentName)
         {
             Description = LocalizableStrings.ProjectPathArgumentDescription,
             Arity = ArgumentArity.OneOrMore,
         }.AddCompletions(Complete.ProjectReferencesFromProjectFile);
 
-        public static readonly CliOption<string> FrameworkOption = new("--framework", "-f")
+        public static readonly Option<string> FrameworkOption = new("--framework", "-f")
         {
             Description = LocalizableStrings.CmdFrameworkDescription,
             HelpName = CommonLocalizableStrings.CmdFramework
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("reference", LocalizableStrings.AppFullName);
+            var command = new Command("reference", LocalizableStrings.AppFullName);
 
             command.Arguments.Add(ProjectPathArgument);
             command.Options.Add(FrameworkOption);
diff --git a/src/Cli/dotnet/commands/dotnet-restore/RestoreCommandParser.cs b/src/Cli/dotnet/commands/dotnet-restore/RestoreCommandParser.cs
index 145c9c7f9117..02588c66cd55 100644
--- a/src/Cli/dotnet/commands/dotnet-restore/RestoreCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-restore/RestoreCommandParser.cs
@@ -12,20 +12,20 @@ internal static class RestoreCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-restore";
 
-        public static readonly CliArgument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
+        public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CommonLocalizableStrings.SolutionOrProjectArgumentName)
         {
             Description = CommonLocalizableStrings.SolutionOrProjectArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        public static readonly CliOption<IEnumerable<string>> SourceOption = new ForwardedOption<IEnumerable<string>>("--source", "-s")
+        public static readonly Option<IEnumerable<string>> SourceOption = new ForwardedOption<IEnumerable<string>>("--source", "-s")
         {
             Description = LocalizableStrings.CmdSourceOptionDescription,
             HelpName = LocalizableStrings.CmdSourceOption
         }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")
         .AllowSingleArgPerToken();
 
-        private static IEnumerable<CliOption> FullRestoreOptions() =>
+        private static IEnumerable<Option> FullRestoreOptions() =>
             ImplicitRestoreOptions(true, true, true, true).Concat(
                 [
                     CommonOptions.VerbosityOption,
@@ -50,14 +50,14 @@ private static IEnumerable<CliOption> FullRestoreOptions() =>
                     }.ForwardAs("-property:RestoreForceEvaluate=true"),
                 ]);
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             var command = new DocumentedCommand("restore", DocsLink, LocalizableStrings.AppFullName);
 
@@ -75,7 +75,7 @@ private static CliCommand ConstructCommand()
             return command;
         }
 
-        public static void AddImplicitRestoreOptions(CliCommand command, bool showHelp = false, bool useShortOptions = false, bool includeRuntimeOption = true, bool includeNoDependenciesOption = true)
+        public static void AddImplicitRestoreOptions(Command command, bool showHelp = false, bool useShortOptions = false, bool includeRuntimeOption = true, bool includeNoDependenciesOption = true)
         {
             foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions, includeRuntimeOption, includeNoDependenciesOption))
             {
@@ -101,7 +101,7 @@ public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
             return $"-property:RuntimeIdentifiers={string.Join("%3B", convertedRids)}";
         }
 
-        private static IEnumerable<CliOption> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
+        private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
         {
             if (showHelp && useShortOptions)
             {
@@ -109,7 +109,7 @@ private static IEnumerable<CliOption> ImplicitRestoreOptions(bool showHelp, bool
             }
             else
             {
-                CliOption<IEnumerable<string>> sourceOption = new ForwardedOption<IEnumerable<string>>("--source")
+                Option<IEnumerable<string>> sourceOption = new ForwardedOption<IEnumerable<string>>("--source")
                 {
                     Description = showHelp ? LocalizableStrings.CmdSourceOptionDescription : string.Empty,
                     HelpName = LocalizableStrings.CmdSourceOption,
@@ -180,7 +180,7 @@ private static IEnumerable<CliOption> ImplicitRestoreOptions(bool showHelp, bool
 
             if (includeRuntimeOption)
             {
-                CliOption<IEnumerable<string>> runtimeOption = new ForwardedOption<IEnumerable<string>>("--runtime")
+                Option<IEnumerable<string>> runtimeOption = new ForwardedOption<IEnumerable<string>>("--runtime")
                 {
                     Description = LocalizableStrings.CmdRuntimeOptionDescription,
                     HelpName = LocalizableStrings.CmdRuntimeOption,
diff --git a/src/Cli/dotnet/commands/dotnet-run/RunCommand.cs b/src/Cli/dotnet/commands/dotnet-run/RunCommand.cs
index 6f802257c3be..ef9cd90470e8 100644
--- a/src/Cli/dotnet/commands/dotnet-run/RunCommand.cs
+++ b/src/Cli/dotnet/commands/dotnet-run/RunCommand.cs
@@ -265,8 +265,8 @@ static void ValidatePreconditions(ProjectInstance project)
 
             static Dictionary<string, List<string>>? DeriveUserPassedProperties(string[] args)
             {
-                var fakeCommand = new System.CommandLine.CliCommand("dotnet") { CommonOptions.PropertiesOption };
-                var propertyParsingConfiguration = new System.CommandLine.CliConfiguration(fakeCommand);
+                var fakeCommand = new System.CommandLine.Command("dotnet") { CommonOptions.PropertiesOption };
+                var propertyParsingConfiguration = new System.CommandLine.CommandLineConfiguration(fakeCommand);
                 var propertyParseResult = propertyParsingConfiguration.Parse(args);
                 var propertyValues = propertyParseResult.GetValue(CommonOptions.PropertiesOption);
 
diff --git a/src/Cli/dotnet/commands/dotnet-run/RunCommandParser.cs b/src/Cli/dotnet/commands/dotnet-run/RunCommandParser.cs
index f2fff28a7e69..ad4987d6a71c 100644
--- a/src/Cli/dotnet/commands/dotnet-run/RunCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-run/RunCommandParser.cs
@@ -11,56 +11,56 @@ internal static class RunCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-run";
 
-        public static readonly CliOption<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
+        public static readonly Option<string> ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
 
-        public static readonly CliOption<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
+        public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
 
-        public static readonly CliOption<string> RuntimeOption = CommonOptions.RuntimeOption;
+        public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption;
 
-        public static readonly CliOption<string> ProjectOption = new("--project")
+        public static readonly Option<string> ProjectOption = new("--project")
         {
             Description = LocalizableStrings.CommandOptionProjectDescription
         };
 
-        public static readonly CliOption<string[]> PropertyOption = CommonOptions.PropertiesOption;
+        public static readonly Option<string[]> PropertyOption = CommonOptions.PropertiesOption;
 
-        public static readonly CliOption<string> LaunchProfileOption = new("--launch-profile", "-lp")
+        public static readonly Option<string> LaunchProfileOption = new("--launch-profile", "-lp")
         {
             Description = LocalizableStrings.CommandOptionLaunchProfileDescription
         };
 
-        public static readonly CliOption<bool> NoLaunchProfileOption = new("--no-launch-profile")
+        public static readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
         {
             Description = LocalizableStrings.CommandOptionNoLaunchProfileDescription
         };
 
-        public static readonly CliOption<bool> NoBuildOption = new("--no-build")
+        public static readonly Option<bool> NoBuildOption = new("--no-build")
         {
             Description = LocalizableStrings.CommandOptionNoBuildDescription
         };
 
-        public static readonly CliOption<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-        public static readonly CliOption<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
+        public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
 
-        public static readonly CliOption SelfContainedOption = CommonOptions.SelfContainedOption;
+        public static readonly Option SelfContainedOption = CommonOptions.SelfContainedOption;
 
-        public static readonly CliOption NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+        public static readonly Option NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
 
-        public static readonly CliArgument<string[]> ApplicationArguments = new("applicationArguments")
+        public static readonly Argument<string[]> ApplicationArguments = new("applicationArguments")
         {
             DefaultValueFactory = _ => Array.Empty<string>(),
             Description = "Arguments passed to the application that is being run."
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("run", DocsLink, LocalizableStrings.AppFullName);
 
diff --git a/src/Cli/dotnet/commands/dotnet-sdk/SdkCommandParser.cs b/src/Cli/dotnet/commands/dotnet-sdk/SdkCommandParser.cs
index 4222167d735d..da0ddf89b1be 100644
--- a/src/Cli/dotnet/commands/dotnet-sdk/SdkCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sdk/SdkCommandParser.cs
@@ -11,14 +11,14 @@ internal static class SdkCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-sdk";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("sdk", DocsLink, LocalizableStrings.AppFullName);
             command.Subcommands.Add(SdkCheckCommandParser.GetCommand());
diff --git a/src/Cli/dotnet/commands/dotnet-sdk/check/SdkCheckCommandParser.cs b/src/Cli/dotnet/commands/dotnet-sdk/check/SdkCheckCommandParser.cs
index 5191f150d472..ddce37cace95 100644
--- a/src/Cli/dotnet/commands/dotnet-sdk/check/SdkCheckCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sdk/check/SdkCheckCommandParser.cs
@@ -7,16 +7,16 @@ namespace Microsoft.DotNet.Tools.Sdk.Check
 {
     internal static class SdkCheckCommandParser
     {
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("check", LocalizableStrings.AppFullName);
+            Command command = new("check", LocalizableStrings.AppFullName);
 
             command.SetAction(SdkCheckCommand.Run);
 
diff --git a/src/Cli/dotnet/commands/dotnet-sln/SlnCommandParser.cs b/src/Cli/dotnet/commands/dotnet-sln/SlnCommandParser.cs
index b2a2f685b752..b4c78f9ec0c4 100644
--- a/src/Cli/dotnet/commands/dotnet-sln/SlnCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sln/SlnCommandParser.cs
@@ -8,6 +8,7 @@
 using Microsoft.VisualStudio.SolutionPersistence.Serializer;
 using NuGet.Packaging;
 using LocalizableStrings = Microsoft.DotNet.Tools.Sln.LocalizableStrings;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -17,21 +18,21 @@ internal static class SlnCommandParser
 
         public static readonly string CommandName = "solution";
         public static readonly string CommandAlias = "sln";
-        public static readonly CliArgument<string> SlnArgument = new CliArgument<string>(LocalizableStrings.SolutionArgumentName)
+        public static readonly Argument<string> SlnArgument = new Argument<string>(LocalizableStrings.SolutionArgumentName)
         {
             HelpName = LocalizableStrings.SolutionArgumentName,
             Description = LocalizableStrings.SolutionArgumentDescription,
             Arity = ArgumentArity.ZeroOrOne
         }.DefaultToCurrentDirectory();
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new(CommandName, DocsLink, LocalizableStrings.AppFullName);
 
diff --git a/src/Cli/dotnet/commands/dotnet-sln/add/SlnAddParser.cs b/src/Cli/dotnet/commands/dotnet-sln/add/SlnAddParser.cs
index 2965bfc23800..6a74d610f4e7 100644
--- a/src/Cli/dotnet/commands/dotnet-sln/add/SlnAddParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sln/add/SlnAddParser.cs
@@ -9,33 +9,33 @@ namespace Microsoft.DotNet.Cli
 {
     public static class SlnAddParser
     {
-        public static readonly CliArgument<IEnumerable<string>> ProjectPathArgument = new(LocalizableStrings.AddProjectPathArgumentName)
+        public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new(LocalizableStrings.AddProjectPathArgumentName)
         {
             HelpName = LocalizableStrings.AddProjectPathArgumentName,
             Description = LocalizableStrings.AddProjectPathArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore,
         };
 
-        public static readonly CliOption<bool> InRootOption = new("--in-root")
+        public static readonly Option<bool> InRootOption = new("--in-root")
         {
             Description = LocalizableStrings.InRoot
         };
 
-        public static readonly CliOption<string> SolutionFolderOption = new("--solution-folder", "-s")
+        public static readonly Option<string> SolutionFolderOption = new("--solution-folder", "-s")
         {
             Description = LocalizableStrings.AddProjectSolutionFolderArgumentDescription
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("add", LocalizableStrings.AddAppFullName);
+            Command command = new("add", LocalizableStrings.AddAppFullName);
 
             command.Arguments.Add(ProjectPathArgument);
             command.Options.Add(InRootOption);
diff --git a/src/Cli/dotnet/commands/dotnet-sln/list/SlnListParser.cs b/src/Cli/dotnet/commands/dotnet-sln/list/SlnListParser.cs
index e0510ba5090c..4eaa4b933f11 100644
--- a/src/Cli/dotnet/commands/dotnet-sln/list/SlnListParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sln/list/SlnListParser.cs
@@ -9,18 +9,18 @@ namespace Microsoft.DotNet.Cli
 {
     public static class SlnListParser
     {
-        public static readonly CliOption<bool> SolutionFolderOption = new("--solution-folders") { Description = LocalizableStrings.ListSolutionFoldersArgumentDescription };
+        public static readonly Option<bool> SolutionFolderOption = new("--solution-folders") { Description = LocalizableStrings.ListSolutionFoldersArgumentDescription };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("list", LocalizableStrings.ListAppFullName);
+            Command command = new("list", LocalizableStrings.ListAppFullName);
 
             command.Options.Add(SolutionFolderOption);
             command.SetAction((parseResult) => new ListProjectsInSolutionCommand(parseResult).Execute());
diff --git a/src/Cli/dotnet/commands/dotnet-sln/migrate/SlnMigrateCommandParser.cs b/src/Cli/dotnet/commands/dotnet-sln/migrate/SlnMigrateCommandParser.cs
index 90b6a9dac7f3..423d0999108b 100644
--- a/src/Cli/dotnet/commands/dotnet-sln/migrate/SlnMigrateCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sln/migrate/SlnMigrateCommandParser.cs
@@ -9,16 +9,16 @@ namespace Microsoft.DotNet.Cli
 {
     public static class SlnMigrateCommandParser
     {
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("migrate", LocalizableStrings.MigrateAppFullName);
+            Command command = new("migrate", LocalizableStrings.MigrateAppFullName);
 
             command.Arguments.Add(SlnCommandParser.SlnArgument);
 
diff --git a/src/Cli/dotnet/commands/dotnet-sln/remove/SlnRemoveParser.cs b/src/Cli/dotnet/commands/dotnet-sln/remove/SlnRemoveParser.cs
index 748f118e40f8..11d7be57702c 100644
--- a/src/Cli/dotnet/commands/dotnet-sln/remove/SlnRemoveParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-sln/remove/SlnRemoveParser.cs
@@ -9,23 +9,23 @@ namespace Microsoft.DotNet.Cli
 {
     public static class SlnRemoveParser
     {
-        public static readonly CliArgument<IEnumerable<string>> ProjectPathArgument = new(LocalizableStrings.RemoveProjectPathArgumentName)
+        public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new(LocalizableStrings.RemoveProjectPathArgumentName)
         {
             HelpName = LocalizableStrings.RemoveProjectPathArgumentName,
             Description = LocalizableStrings.RemoveProjectPathArgumentDescription,
             Arity = ArgumentArity.ZeroOrMore
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("remove", LocalizableStrings.RemoveAppFullName);
+            Command command = new("remove", LocalizableStrings.RemoveAppFullName);
 
             command.Arguments.Add(ProjectPathArgument);
 
diff --git a/src/Cli/dotnet/commands/dotnet-store/StoreCommandParser.cs b/src/Cli/dotnet/commands/dotnet-store/StoreCommandParser.cs
index aa04bbec45ca..4e3f6a7258b6 100644
--- a/src/Cli/dotnet/commands/dotnet-store/StoreCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-store/StoreCommandParser.cs
@@ -11,12 +11,12 @@ internal static class StoreCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-store";
 
-        public static readonly CliArgument<IEnumerable<string>> Argument = new("argument")
+        public static readonly Argument<IEnumerable<string>> Argument = new("argument")
         {
             Arity = ArgumentArity.ZeroOrMore,
         };
 
-        public static readonly CliOption<IEnumerable<string>> ManifestOption = new ForwardedOption<IEnumerable<string>>("--manifest", "-m")
+        public static readonly Option<IEnumerable<string>> ManifestOption = new ForwardedOption<IEnumerable<string>>("--manifest", "-m")
         {
             Description = LocalizableStrings.ProjectManifestDescription,
             HelpName = LocalizableStrings.ProjectManifest
@@ -43,42 +43,42 @@ internal static class StoreCommandParser
             }
         }).AllowSingleArgPerToken();
 
-        public static readonly CliOption<string> FrameworkVersionOption = new ForwardedOption<string>("--framework-version")
+        public static readonly Option<string> FrameworkVersionOption = new ForwardedOption<string>("--framework-version")
         {
             Description = LocalizableStrings.FrameworkVersionOptionDescription,
             HelpName = LocalizableStrings.FrameworkVersionOption
         }.ForwardAsSingle(o => $"-property:RuntimeFrameworkVersion={o}");
 
-        public static readonly CliOption<string> OutputOption = new ForwardedOption<string>("--output", "-o")
+        public static readonly Option<string> OutputOption = new ForwardedOption<string>("--output", "-o")
         {
             Description = LocalizableStrings.OutputOptionDescription,
             HelpName = LocalizableStrings.OutputOption
         }.ForwardAsOutputPath("ComposeDir");
 
-        public static readonly CliOption<string> WorkingDirOption = new ForwardedOption<string>("--working-dir", "-w")
+        public static readonly Option<string> WorkingDirOption = new ForwardedOption<string>("--working-dir", "-w")
         {
             Description = LocalizableStrings.IntermediateWorkingDirOptionDescription,
             HelpName = LocalizableStrings.IntermediateWorkingDirOption
         }.ForwardAsSingle(o => $"-property:ComposeWorkingDir={CommandDirectoryContext.GetFullPath(o)}");
 
-        public static readonly CliOption<bool> SkipOptimizationOption = new ForwardedOption<bool>("--skip-optimization")
+        public static readonly Option<bool> SkipOptimizationOption = new ForwardedOption<bool>("--skip-optimization")
         {
             Description = LocalizableStrings.SkipOptimizationOptionDescription
         }.ForwardAs("-property:SkipOptimization=true");
 
-        public static readonly CliOption<bool> SkipSymbolsOption = new ForwardedOption<bool>("--skip-symbols")
+        public static readonly Option<bool> SkipSymbolsOption = new ForwardedOption<bool>("--skip-symbols")
         {
             Description = LocalizableStrings.SkipSymbolsOptionDescription
         }.ForwardAs("-property:CreateProfilingSymbols=false");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("store", DocsLink, LocalizableStrings.AppDescription);
 
diff --git a/src/Cli/dotnet/commands/dotnet-test/Program.cs b/src/Cli/dotnet/commands/dotnet-test/Program.cs
index ec586616a4e1..cd406b07329b 100644
--- a/src/Cli/dotnet/commands/dotnet-test/Program.cs
+++ b/src/Cli/dotnet/commands/dotnet-test/Program.cs
@@ -305,7 +305,7 @@ private static bool ContainsBuiltTestSources(string[] args)
 
         private static void SetEnvironmentVariablesFromParameters(TestCommand testCommand, ParseResult parseResult)
         {
-            CliOption<IEnumerable<string>> option = TestCommandParser.EnvOption;
+            Option<IEnumerable<string>> option = TestCommandParser.EnvOption;
 
             if (parseResult.GetResult(option) is null)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs b/src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs
index df414cbfa4e9..b8dfd4fa1e72 100644
--- a/src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-test/TestCommandParser.cs
@@ -11,37 +11,37 @@ internal static class TestCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-test";
 
-        public static readonly CliOption<string> SettingsOption = new ForwardedOption<string>("--settings", "-s")
+        public static readonly Option<string> SettingsOption = new ForwardedOption<string>("--settings", "-s")
         {
             Description = LocalizableStrings.CmdSettingsDescription,
             HelpName = LocalizableStrings.CmdSettingsFile
         }.ForwardAsSingle(o => $"-property:VSTestSetting={SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
 
-        public static readonly CliOption<bool> ListTestsOption = new ForwardedOption<bool>("--list-tests", "-t")
+        public static readonly Option<bool> ListTestsOption = new ForwardedOption<bool>("--list-tests", "-t")
         {
             Description = LocalizableStrings.CmdListTestsDescription
         }.ForwardAs("-property:VSTestListTests=true");
 
-        public static readonly CliOption<IEnumerable<string>> EnvOption = new CliOption<IEnumerable<string>>("--environment", "-e")
+        public static readonly Option<IEnumerable<string>> EnvOption = new Option<IEnumerable<string>>("--environment", "-e")
         {
             Description = LocalizableStrings.CmdEnvironmentVariableDescription,
             HelpName = LocalizableStrings.CmdEnvironmentVariableExpression
         }.AllowSingleArgPerToken();
 
-        public static readonly CliOption<string> FilterOption = new ForwardedOption<string>("--filter")
+        public static readonly Option<string> FilterOption = new ForwardedOption<string>("--filter")
         {
             Description = LocalizableStrings.CmdTestCaseFilterDescription,
             HelpName = LocalizableStrings.CmdTestCaseFilterExpression
         }.ForwardAsSingle(o => $"-property:VSTestTestCaseFilter={SurroundWithDoubleQuotes(o)}");
 
-        public static readonly CliOption<IEnumerable<string>> AdapterOption = new ForwardedOption<IEnumerable<string>>("--test-adapter-path")
+        public static readonly Option<IEnumerable<string>> AdapterOption = new ForwardedOption<IEnumerable<string>>("--test-adapter-path")
         {
             Description = LocalizableStrings.CmdTestAdapterPathDescription,
             HelpName = LocalizableStrings.CmdTestAdapterPath
         }.ForwardAsSingle(o => $"-property:VSTestTestAdapterPath={SurroundWithDoubleQuotes(string.Join(";", o.Select(CommandDirectoryContext.GetFullPath)))}")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption<IEnumerable<string>> LoggerOption = new ForwardedOption<IEnumerable<string>>("--logger", "-l")
+        public static readonly Option<IEnumerable<string>> LoggerOption = new ForwardedOption<IEnumerable<string>>("--logger", "-l")
         {
             Description = LocalizableStrings.CmdLoggerDescription,
             HelpName = LocalizableStrings.CmdLoggerOption
@@ -53,53 +53,53 @@ internal static class TestCommandParser
         })
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption<string> OutputOption = new ForwardedOption<string>("--output", "-o")
+        public static readonly Option<string> OutputOption = new ForwardedOption<string>("--output", "-o")
         {
             Description = LocalizableStrings.CmdOutputDescription,
             HelpName = LocalizableStrings.CmdOutputDir
         }
         .ForwardAsOutputPath("OutputPath", true);
 
-        public static readonly CliOption<string> DiagOption = new ForwardedOption<string>("--diag", "-d")
+        public static readonly Option<string> DiagOption = new ForwardedOption<string>("--diag", "-d")
         {
             Description = LocalizableStrings.CmdPathTologFileDescription,
             HelpName = LocalizableStrings.CmdPathToLogFile
         }
         .ForwardAsSingle(o => $"-property:VSTestDiag={SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
 
-        public static readonly CliOption<bool> NoBuildOption = new ForwardedOption<bool>("--no-build")
+        public static readonly Option<bool> NoBuildOption = new ForwardedOption<bool>("--no-build")
         {
             Description = LocalizableStrings.CmdNoBuildDescription
         }.ForwardAs("-property:VSTestNoBuild=true");
 
-        public static readonly CliOption<string> ResultsOption = new ForwardedOption<string>("--results-directory")
+        public static readonly Option<string> ResultsOption = new ForwardedOption<string>("--results-directory")
         {
             Description = LocalizableStrings.CmdResultsDirectoryDescription,
             HelpName = LocalizableStrings.CmdPathToResultsDirectory
         }.ForwardAsSingle(o => $"-property:VSTestResultsDirectory={SurroundWithDoubleQuotes(CommandDirectoryContext.GetFullPath(o))}");
 
-        public static readonly CliOption<IEnumerable<string>> CollectOption = new ForwardedOption<IEnumerable<string>>("--collect")
+        public static readonly Option<IEnumerable<string>> CollectOption = new ForwardedOption<IEnumerable<string>>("--collect")
         {
             Description = LocalizableStrings.cmdCollectDescription,
             HelpName = LocalizableStrings.cmdCollectFriendlyName
         }.ForwardAsSingle(o => $"-property:VSTestCollect=\"{string.Join(";", GetSemiColonEscapedArgs(o))}\"")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption<bool> BlameOption = new ForwardedOption<bool>("--blame")
+        public static readonly Option<bool> BlameOption = new ForwardedOption<bool>("--blame")
         {
             Description = LocalizableStrings.CmdBlameDescription
         }.ForwardAs("-property:VSTestBlame=true");
 
-        public static readonly CliOption<bool> BlameCrashOption = new ForwardedOption<bool>("--blame-crash")
+        public static readonly Option<bool> BlameCrashOption = new ForwardedOption<bool>("--blame-crash")
         {
             Description = LocalizableStrings.CmdBlameCrashDescription
         }.ForwardAs("-property:VSTestBlameCrash=true");
 
-        public static readonly CliOption<string> BlameCrashDumpOption = CreateBlameCrashDumpOption();
+        public static readonly Option<string> BlameCrashDumpOption = CreateBlameCrashDumpOption();
 
-        private static CliOption<string> CreateBlameCrashDumpOption()
+        private static Option<string> CreateBlameCrashDumpOption()
         {
-            CliOption<string> result = new ForwardedOption<string>("--blame-crash-dump-type")
+            Option<string> result = new ForwardedOption<string>("--blame-crash-dump-type")
             {
                 Description = LocalizableStrings.CmdBlameCrashDumpTypeDescription,
                 HelpName = LocalizableStrings.CrashDumpTypeArgumentName,
@@ -109,21 +109,21 @@ private static CliOption<string> CreateBlameCrashDumpOption()
             return result;
         }
 
-        public static readonly CliOption<bool> BlameCrashAlwaysOption = new ForwardedOption<bool>("--blame-crash-collect-always")
+        public static readonly Option<bool> BlameCrashAlwaysOption = new ForwardedOption<bool>("--blame-crash-collect-always")
         {
             Description = LocalizableStrings.CmdBlameCrashCollectAlwaysDescription
         }.ForwardAsMany(o => new[] { "-property:VSTestBlameCrash=true", "-property:VSTestBlameCrashCollectAlways=true" });
 
-        public static readonly CliOption<bool> BlameHangOption = new ForwardedOption<bool>("--blame-hang")
+        public static readonly Option<bool> BlameHangOption = new ForwardedOption<bool>("--blame-hang")
         {
             Description = LocalizableStrings.CmdBlameHangDescription
         }.ForwardAs("-property:VSTestBlameHang=true");
 
-        public static readonly CliOption<string> BlameHangDumpOption = CreateBlameHangDumpOption();
+        public static readonly Option<string> BlameHangDumpOption = CreateBlameHangDumpOption();
 
-        private static CliOption<string> CreateBlameHangDumpOption()
+        private static Option<string> CreateBlameHangDumpOption()
         {
-            CliOption<string> result = new ForwardedOption<string>("--blame-hang-dump-type")
+            Option<string> result = new ForwardedOption<string>("--blame-hang-dump-type")
             {
                 Description = LocalizableStrings.CmdBlameHangDumpTypeDescription,
                 HelpName = LocalizableStrings.HangDumpTypeArgumentName
@@ -133,28 +133,28 @@ private static CliOption<string> CreateBlameHangDumpOption()
             return result;
         }
 
-        public static readonly CliOption<string> BlameHangTimeoutOption = new ForwardedOption<string>("--blame-hang-timeout")
+        public static readonly Option<string> BlameHangTimeoutOption = new ForwardedOption<string>("--blame-hang-timeout")
         {
             Description = LocalizableStrings.CmdBlameHangTimeoutDescription,
             HelpName = LocalizableStrings.HangTimeoutArgumentName
         }.ForwardAsMany(o => new[] { "-property:VSTestBlameHang=true", $"-property:VSTestBlameHangTimeout={o}" });
 
-        public static readonly CliOption<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
+        public static readonly Option<bool> NoLogoOption = new ForwardedOption<bool>("--nologo")
         {
             Description = LocalizableStrings.CmdNoLogo
         }.ForwardAs("-property:VSTestNoLogo=true");
 
-        public static readonly CliOption<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+        public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
 
-        public static readonly CliOption<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
+        public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(LocalizableStrings.FrameworkOptionDescription);
 
-        public static readonly CliOption ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
+        public static readonly Option ConfigurationOption = CommonOptions.ConfigurationOption(LocalizableStrings.ConfigurationOptionDescription);
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
 
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
@@ -166,28 +166,28 @@ private static bool IsTestingPlatformEnabled()
             return isTestingPlatformEnabled;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
 #if RELEASE
-            return GetVSTestCliCommand();
+            return GetVSTestCommand();
 #else
             bool isTestingPlatformEnabled = IsTestingPlatformEnabled();
             string testingSdkName = isTestingPlatformEnabled ? "testingplatform" : "vstest";
 
             if (isTestingPlatformEnabled)
             {
-                return GetTestingPlatformCliCommand();
+                return GetTestingPlatformCommand();
             }
             else
             {
-                return GetVSTestCliCommand();
+                return GetVSTestCommand();
             }
 
             throw new InvalidOperationException($"Testing sdk not supported: {testingSdkName}");
 #endif
         }
 
-        private static CliCommand GetTestingPlatformCliCommand()
+        private static Command GetTestingPlatformCommand()
         {
             var command = new TestingPlatformCommand("test");
             command.SetAction(parseResult => command.Run(parseResult));
@@ -207,7 +207,7 @@ private static CliCommand GetTestingPlatformCliCommand()
             return command;
         }
 
-        private static CliCommand GetVSTestCliCommand()
+        private static Command GetVSTestCommand()
         {
             DocumentedCommand command = new("test", DocsLink, LocalizableStrings.AppFullName)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-test/TestingPlatformCommand.cs b/src/Cli/dotnet/commands/dotnet-test/TestingPlatformCommand.cs
index e73dddebf244..20c88566090d 100644
--- a/src/Cli/dotnet/commands/dotnet-test/TestingPlatformCommand.cs
+++ b/src/Cli/dotnet/commands/dotnet-test/TestingPlatformCommand.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.DotNet.Cli
 {
-    internal partial class TestingPlatformCommand : CliCommand, ICustomHelp
+    internal partial class TestingPlatformCommand : Command, ICustomHelp
     {
         private readonly ConcurrentBag<TestApplication> _testApplications = [];
 
diff --git a/src/Cli/dotnet/commands/dotnet-test/TestingPlatformOptions.cs b/src/Cli/dotnet/commands/dotnet-test/TestingPlatformOptions.cs
index dda8123146ba..bf0df73d3d59 100644
--- a/src/Cli/dotnet/commands/dotnet-test/TestingPlatformOptions.cs
+++ b/src/Cli/dotnet/commands/dotnet-test/TestingPlatformOptions.cs
@@ -8,69 +8,69 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class TestingPlatformOptions
     {
-        public static readonly CliOption<string> MaxParallelTestModulesOption = new("--max-parallel-test-modules", "-mptm")
+        public static readonly Option<string> MaxParallelTestModulesOption = new("--max-parallel-test-modules", "-mptm")
         {
             Description = LocalizableStrings.CmdMaxParallelTestModulesDescription,
         };
 
-        public static readonly CliOption<string> AdditionalMSBuildParametersOption = new("--additional-msbuild-parameters")
+        public static readonly Option<string> AdditionalMSBuildParametersOption = new("--additional-msbuild-parameters")
         {
             Description = LocalizableStrings.CmdAdditionalMSBuildParametersDescription,
         };
 
-        public static readonly CliOption<string> TestModulesFilterOption = new("--test-modules")
+        public static readonly Option<string> TestModulesFilterOption = new("--test-modules")
         {
             Description = LocalizableStrings.CmdTestModulesDescription
         };
 
-        public static readonly CliOption<string> TestModulesRootDirectoryOption = new("--root-directory")
+        public static readonly Option<string> TestModulesRootDirectoryOption = new("--root-directory")
         {
             Description = LocalizableStrings.CmdTestModulesRootDirectoryDescription
         };
 
-        public static readonly CliOption<string> NoBuildOption = new("--no-build")
+        public static readonly Option<string> NoBuildOption = new("--no-build")
         {
             Description = LocalizableStrings.CmdNoBuildDescription,
             Arity = ArgumentArity.Zero
         };
 
-        public static readonly CliOption<string> NoRestoreOption = new("--no-restore")
+        public static readonly Option<string> NoRestoreOption = new("--no-restore")
         {
             Description = LocalizableStrings.CmdNoRestoreDescription,
             Arity = ArgumentArity.Zero
         };
 
-        public static readonly CliOption<string> ArchitectureOption = new("--arch")
+        public static readonly Option<string> ArchitectureOption = new("--arch")
         {
             Description = LocalizableStrings.CmdArchitectureDescription,
             Arity = ArgumentArity.ExactlyOne
         };
 
-        public static readonly CliOption<string> ConfigurationOption = new("--configuration")
+        public static readonly Option<string> ConfigurationOption = new("--configuration")
         {
             Description = LocalizableStrings.CmdConfigurationDescription,
             Arity = ArgumentArity.ExactlyOne
         };
 
-        public static readonly CliOption<string> ProjectOption = new("--project")
+        public static readonly Option<string> ProjectOption = new("--project")
         {
             Description = LocalizableStrings.CmdProjectDescription,
             Arity = ArgumentArity.ExactlyOne
         };
 
-        public static readonly CliOption<string> ListTestsOption = new("--list-tests")
+        public static readonly Option<string> ListTestsOption = new("--list-tests")
         {
             Description = LocalizableStrings.CmdListTestsDescription,
             Arity = ArgumentArity.Zero
         };
 
-        public static readonly CliOption<string> SolutionOption = new("--solution")
+        public static readonly Option<string> SolutionOption = new("--solution")
         {
             Description = LocalizableStrings.CmdSolutionDescription,
             Arity = ArgumentArity.ExactlyOne
         };
 
-        public static readonly CliOption<string> DirectoryOption = new("--directory")
+        public static readonly Option<string> DirectoryOption = new("--directory")
         {
             Description = LocalizableStrings.CmdDirectoryDescription,
             Arity = ArgumentArity.ExactlyOne
diff --git a/src/Cli/dotnet/commands/dotnet-tool/ToolCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/ToolCommandParser.cs
index 8208ea36d612..bd78e1b7bb38 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/ToolCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/ToolCommandParser.cs
@@ -10,14 +10,14 @@ internal static class ToolCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-tool";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("tool", DocsLink, LocalizableStrings.CommandDescription);
 
diff --git a/src/Cli/dotnet/commands/dotnet-tool/ToolCommandRestorePassThroughOptions.cs b/src/Cli/dotnet/commands/dotnet-tool/ToolCommandRestorePassThroughOptions.cs
index 91c90af36dfb..cfb9a923621d 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/ToolCommandRestorePassThroughOptions.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/ToolCommandRestorePassThroughOptions.cs
@@ -10,28 +10,28 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolCommandRestorePassThroughOptions
     {
-        public static CliOption<bool> DisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
+        public static Option<bool> DisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
         {
             Description = LocalizableStrings.CmdDisableParallelOptionDescription
         }.ForwardAs("--disable-parallel");
 
-        public static CliOption<bool> NoCacheOption = new ForwardedOption<bool>("--no-cache")
+        public static Option<bool> NoCacheOption = new ForwardedOption<bool>("--no-cache")
         {
             Description = LocalizableStrings.CmdNoCacheOptionDescription,
             Hidden = true
         }.ForwardAs("--no-cache");
 
-        public static CliOption<bool> NoHttpCacheOption = new ForwardedOption<bool>("--no-http-cache")
+        public static Option<bool> NoHttpCacheOption = new ForwardedOption<bool>("--no-http-cache")
         {
             Description = LocalizableStrings.CmdNoCacheOptionDescription
         }.ForwardAs("--no-http-cache");
 
-        public static CliOption<bool> IgnoreFailedSourcesOption = new ForwardedOption<bool>("--ignore-failed-sources")
+        public static Option<bool> IgnoreFailedSourcesOption = new ForwardedOption<bool>("--ignore-failed-sources")
         {
             Description = LocalizableStrings.CmdIgnoreFailedSourcesOptionDescription
         }.ForwardAs("--ignore-failed-sources");
 
-        public static CliOption<bool> InteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
+        public static Option<bool> InteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
         {
             Description = CommonLocalizableStrings.CommandInteractiveOptionDescription
         }.ForwardAs(Constants.RestoreInteractiveOption);
diff --git a/src/Cli/dotnet/commands/dotnet-tool/common/ToolAppliedOption.cs b/src/Cli/dotnet/commands/dotnet-tool/common/ToolAppliedOption.cs
index 0a84f38f09be..cc194e65d93c 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/common/ToolAppliedOption.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/common/ToolAppliedOption.cs
@@ -10,25 +10,25 @@ namespace Microsoft.DotNet.Tools.Tool.Common
 {
     internal class ToolAppliedOption
     {
-        public static CliOption<bool> GlobalOption = new("--global", "-g");
+        public static Option<bool> GlobalOption = new("--global", "-g");
 
-        public static CliOption<bool> LocalOption = new("--local");
+        public static Option<bool> LocalOption = new("--local");
 
-        public static CliOption<bool> UpdateAllOption = new("--all")
+        public static Option<bool> UpdateAllOption = new("--all")
         {
             Description = UpdateToolsLocalizableStrings.UpdateAllOptionDescription
         };
 
-        public static readonly CliOption<string> VersionOption
+        public static readonly Option<string> VersionOption
             = ToolInstallCommandParser.VersionOption
               ?? new("--version"); // Workaround for Mono runtime (https://github.com/dotnet/sdk/issues/41672)
 
-        public static CliOption<string> ToolPathOption = new("--tool-path")
+        public static Option<string> ToolPathOption = new("--tool-path")
         {
             HelpName = Install.LocalizableStrings.ToolPathOptionName
         };
 
-        public static CliOption<string> ToolManifestOption = new("--tool-manifest")
+        public static Option<string> ToolManifestOption = new("--tool-manifest")
         {
             HelpName = Install.LocalizableStrings.ManifestPathOptionName,
             Arity = ArgumentArity.ZeroOrOne
diff --git a/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallCommandParser.cs
index 3c21b0c5bd19..a9c4421987fb 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallCommandParser.cs
@@ -11,85 +11,85 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolInstallCommandParser
     {
-        public static readonly CliArgument<string> PackageIdArgument = new("packageId")
+        public static readonly Argument<string> PackageIdArgument = new("packageId")
         {
             HelpName = LocalizableStrings.PackageIdArgumentName,
             Description = LocalizableStrings.PackageIdArgumentDescription
         };
 
-        public static readonly CliOption<string> VersionOption = new("--version")
+        public static readonly Option<string> VersionOption = new("--version")
         {
             Description = LocalizableStrings.VersionOptionDescription,
             HelpName = LocalizableStrings.VersionOptionName
         };
 
-        public static readonly CliOption<string> ConfigOption = new("--configfile")
+        public static readonly Option<string> ConfigOption = new("--configfile")
         {
             Description = LocalizableStrings.ConfigFileOptionDescription,
             HelpName = LocalizableStrings.ConfigFileOptionName
         };
 
-        public static readonly CliOption<string[]> SourceOption = new CliOption<string[]>("--source")
+        public static readonly Option<string[]> SourceOption = new Option<string[]>("--source")
         {
             Description = LocalizableStrings.SourceOptionDescription,
             HelpName = LocalizableStrings.SourceOptionName
         }.AllowSingleArgPerToken();
 
-        public static readonly CliOption<string[]> AddSourceOption = new CliOption<string[]>("--add-source")
+        public static readonly Option<string[]> AddSourceOption = new Option<string[]>("--add-source")
         {
             Description = LocalizableStrings.AddSourceOptionDescription,
             HelpName = LocalizableStrings.AddSourceOptionName
         }.AllowSingleArgPerToken();
 
-        public static readonly CliOption<string> FrameworkOption = new("--framework")
+        public static readonly Option<string> FrameworkOption = new("--framework")
         {
             Description = LocalizableStrings.FrameworkOptionDescription,
             HelpName = LocalizableStrings.FrameworkOptionName
         };
 
-        public static readonly CliOption<bool> PrereleaseOption = ToolSearchCommandParser.PrereleaseOption;
+        public static readonly Option<bool> PrereleaseOption = ToolSearchCommandParser.PrereleaseOption;
 
-        public static readonly CliOption<bool> CreateManifestIfNeededOption = new("--create-manifest-if-needed")
+        public static readonly Option<bool> CreateManifestIfNeededOption = new("--create-manifest-if-needed")
         {
             Description = LocalizableStrings.CreateManifestIfNeededOptionDescription
         };
 
-        public static readonly CliOption<bool> AllowPackageDowngradeOption = new("--allow-downgrade")
+        public static readonly Option<bool> AllowPackageDowngradeOption = new("--allow-downgrade")
         {
             Description = LocalizableStrings.AllowPackageDowngradeOptionDescription
         }; 
 
-        public static readonly CliOption<VerbosityOptions> VerbosityOption = CommonOptions.VerbosityOption;
+        public static readonly Option<VerbosityOptions> VerbosityOption = CommonOptions.VerbosityOption;
 
         // Don't use the common options version as we don't want this to be a forwarded option
-        public static readonly CliOption<string> ArchitectureOption = new("--arch", "-a")
+        public static readonly Option<string> ArchitectureOption = new("--arch", "-a")
         {
             Description = CommonLocalizableStrings.ArchitectureOptionDescription
         };
 
-        public static readonly CliOption<bool> RollForwardOption = new("--allow-roll-forward")
+        public static readonly Option<bool> RollForwardOption = new("--allow-roll-forward")
         {
             Description = LocalizableStrings.RollForwardOptionDescription
         };
 
-        public static readonly CliOption<bool> GlobalOption = ToolAppliedOption.GlobalOption;
+        public static readonly Option<bool> GlobalOption = ToolAppliedOption.GlobalOption;
 
-        public static readonly CliOption<bool> LocalOption = ToolAppliedOption.LocalOption;
+        public static readonly Option<bool> LocalOption = ToolAppliedOption.LocalOption;
 
-        public static readonly CliOption<string> ToolPathOption = ToolAppliedOption.ToolPathOption;
+        public static readonly Option<string> ToolPathOption = ToolAppliedOption.ToolPathOption;
 
-        public static readonly CliOption<string> ToolManifestOption = ToolAppliedOption.ToolManifestOption;
+        public static readonly Option<string> ToolManifestOption = ToolAppliedOption.ToolManifestOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("install", LocalizableStrings.CommandDescription);
+            Command command = new("install", LocalizableStrings.CommandDescription);
             command.Arguments.Add(PackageIdArgument);
 
             AddCommandOptions(command);
@@ -104,7 +104,7 @@ private static CliCommand ConstructCommand()
             return command;
         }
 
-        public static CliCommand AddCommandOptions(CliCommand command)
+        public static Command AddCommandOptions(Command command)
         {   
             command.Options.Add(GlobalOption.WithHelpDescription(command, LocalizableStrings.GlobalOptionDescription));
             command.Options.Add(LocalOption.WithHelpDescription(command, LocalizableStrings.LocalOptionDescription));
diff --git a/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallGlobalOrToolPathCommand.cs b/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallGlobalOrToolPathCommand.cs
index 324c5f220096..9f78de78237c 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallGlobalOrToolPathCommand.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/install/ToolInstallGlobalOrToolPathCommand.cs
@@ -106,7 +106,7 @@ public ToolInstallGlobalOrToolPathCommand(
             _reporter = (reporter ?? Reporter.Output);
         }
 
-        public static T GetValueOrDefault<T>(CliOption<T> option, T defaultOption, ParseResult parseResult)
+        public static T GetValueOrDefault<T>(Option<T> option, T defaultOption, ParseResult parseResult)
         {
             if (parseResult.GetResult(option) is { } result &&
                 result.GetValueOrDefault<T>() is { } t)
diff --git a/src/Cli/dotnet/commands/dotnet-tool/list/ToolListCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/list/ToolListCommandParser.cs
index 9ee1017ec86c..1cc77ab12293 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/list/ToolListCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/list/ToolListCommandParser.cs
@@ -6,40 +6,41 @@
 using Microsoft.DotNet.Tools.Tool.Common;
 using Microsoft.DotNet.Tools.Tool.List;
 using LocalizableStrings = Microsoft.DotNet.Tools.Tool.List.LocalizableStrings;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli
 {
     internal static class ToolListCommandParser
     {
-        public static readonly CliArgument<string> PackageIdArgument = new("packageId")
+        public static readonly Argument<string> PackageIdArgument = new("packageId")
         {
             HelpName = LocalizableStrings.PackageIdArgumentName,
             Description = LocalizableStrings.PackageIdArgumentDescription,
             Arity = ArgumentArity.ZeroOrOne,
         };
 
-        public static readonly CliOption<bool> GlobalOption = ToolAppliedOption.GlobalOption;
+        public static readonly Option<bool> GlobalOption = ToolAppliedOption.GlobalOption;
 
-        public static readonly CliOption<bool> LocalOption = ToolAppliedOption.LocalOption;
+        public static readonly Option<bool> LocalOption = ToolAppliedOption.LocalOption;
 
-        public static readonly CliOption<string> ToolPathOption = ToolAppliedOption.ToolPathOption;
+        public static readonly Option<string> ToolPathOption = ToolAppliedOption.ToolPathOption;
 
-        public static readonly CliOption<ToolListOutputFormat> ToolListFormatOption = new("--format")
+        public static readonly Option<ToolListOutputFormat> ToolListFormatOption = new("--format")
         {
             Arity = ArgumentArity.ZeroOrOne,
             DefaultValueFactory = _ => ToolListOutputFormat.table,
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("list", LocalizableStrings.CommandDescription);
+            Command command = new("list", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(PackageIdArgument);
             command.Options.Add(GlobalOption.WithHelpDescription(command, LocalizableStrings.GlobalOptionDescription));
diff --git a/src/Cli/dotnet/commands/dotnet-tool/restore/ToolRestoreCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/restore/ToolRestoreCommandParser.cs
index 878ad39b8b25..e695efaf63c3 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/restore/ToolRestoreCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/restore/ToolRestoreCommandParser.cs
@@ -10,24 +10,24 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolRestoreCommandParser
     {
-        public static readonly CliOption<string> ConfigOption = ToolInstallCommandParser.ConfigOption;
+        public static readonly Option<string> ConfigOption = ToolInstallCommandParser.ConfigOption;
 
-        public static readonly CliOption<string[]> AddSourceOption = ToolInstallCommandParser.AddSourceOption;
+        public static readonly Option<string[]> AddSourceOption = ToolInstallCommandParser.AddSourceOption;
 
-        public static readonly CliOption<string> ToolManifestOption = ToolAppliedOption.ToolManifestOption;
+        public static readonly Option<string> ToolManifestOption = ToolAppliedOption.ToolManifestOption;
 
-        public static readonly CliOption<VerbosityOptions> VerbosityOption = ToolInstallCommandParser.VerbosityOption;
+        public static readonly Option<VerbosityOptions> VerbosityOption = ToolInstallCommandParser.VerbosityOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("restore", LocalizableStrings.CommandDescription);
+            Command command = new("restore", LocalizableStrings.CommandDescription);
 
             command.Options.Add(ConfigOption);
             command.Options.Add(AddSourceOption);
diff --git a/src/Cli/dotnet/commands/dotnet-tool/run/ToolRunCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/run/ToolRunCommandParser.cs
index 1c7138cf49d7..1d3dbeeec97c 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/run/ToolRunCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/run/ToolRunCommandParser.cs
@@ -10,32 +10,32 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolRunCommandParser
     {
-        public static readonly CliArgument<string> CommandNameArgument = new("commandName")
+        public static readonly Argument<string> CommandNameArgument = new("commandName")
         {
             HelpName = LocalizableStrings.CommandNameArgumentName,
             Description = LocalizableStrings.CommandNameArgumentDescription
         };
 
-        public static readonly CliArgument<IEnumerable<string>> CommandArgument = new("toolArguments")
+        public static readonly Argument<IEnumerable<string>> CommandArgument = new("toolArguments")
         {
             Description = "arguments forwarded to the tool"
         };
 
-        public static readonly CliOption<bool> RollForwardOption = new("--allow-roll-forward")
+        public static readonly Option<bool> RollForwardOption = new("--allow-roll-forward")
         {
             Description = Tools.Tool.Install.LocalizableStrings.RollForwardOptionDescription
         };
        
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("run", LocalizableStrings.CommandDescription);
+            Command command = new("run", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(CommandNameArgument);
             command.Arguments.Add(CommandArgument);
diff --git a/src/Cli/dotnet/commands/dotnet-tool/search/ToolSearchCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/search/ToolSearchCommandParser.cs
index 0eab873de056..24ad82f32d91 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/search/ToolSearchCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/search/ToolSearchCommandParser.cs
@@ -9,44 +9,44 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolSearchCommandParser
     {
-        public static readonly CliArgument<string> SearchTermArgument = new("searchTerm")
+        public static readonly Argument<string> SearchTermArgument = new("searchTerm")
         {
             HelpName = LocalizableStrings.SearchTermArgumentName,
             Description = LocalizableStrings.SearchTermDescription
         };
 
-        public static readonly CliOption<bool> DetailOption = new("--detail")
+        public static readonly Option<bool> DetailOption = new("--detail")
         {
             Description = LocalizableStrings.DetailDescription
         };
 
-        public static readonly CliOption<string> SkipOption = new("--skip")
+        public static readonly Option<string> SkipOption = new("--skip")
         {
             Description = LocalizableStrings.SkipDescription,
             HelpName = LocalizableStrings.SkipArgumentName
         };
 
-        public static readonly CliOption<string> TakeOption = new("--take")
+        public static readonly Option<string> TakeOption = new("--take")
         {
             Description = LocalizableStrings.TakeDescription,
             HelpName = LocalizableStrings.TakeArgumentName
         };
 
-        public static readonly CliOption<bool> PrereleaseOption = new("--prerelease")
+        public static readonly Option<bool> PrereleaseOption = new("--prerelease")
         {
             Description = LocalizableStrings.PrereleaseDescription
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("search", LocalizableStrings.CommandDescription);
+            Command command = new("search", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(SearchTermArgument);
 
diff --git a/src/Cli/dotnet/commands/dotnet-tool/uninstall/ToolUninstallCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/uninstall/ToolUninstallCommandParser.cs
index aecf417796df..f5ed2c9939b6 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/uninstall/ToolUninstallCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/uninstall/ToolUninstallCommandParser.cs
@@ -10,26 +10,26 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolUninstallCommandParser
     {
-        public static readonly CliArgument<string> PackageIdArgument = ToolInstallCommandParser.PackageIdArgument;
+        public static readonly Argument<string> PackageIdArgument = ToolInstallCommandParser.PackageIdArgument;
 
-        public static readonly CliOption<bool> GlobalOption = ToolAppliedOption.GlobalOption;
+        public static readonly Option<bool> GlobalOption = ToolAppliedOption.GlobalOption;
 
-        public static readonly CliOption<bool> LocalOption = ToolAppliedOption.LocalOption;
+        public static readonly Option<bool> LocalOption = ToolAppliedOption.LocalOption;
 
-        public static readonly CliOption<string> ToolPathOption = ToolAppliedOption.ToolPathOption;
+        public static readonly Option<string> ToolPathOption = ToolAppliedOption.ToolPathOption;
 
-        public static readonly CliOption<string> ToolManifestOption = ToolAppliedOption.ToolManifestOption;
+        public static readonly Option<string> ToolManifestOption = ToolAppliedOption.ToolManifestOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("uninstall", LocalizableStrings.CommandDescription);
+            Command command = new("uninstall", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(PackageIdArgument);
             command.Options.Add(GlobalOption.WithHelpDescription(command, LocalizableStrings.GlobalOptionDescription));
diff --git a/src/Cli/dotnet/commands/dotnet-tool/update/ToolUpdateCommandParser.cs b/src/Cli/dotnet/commands/dotnet-tool/update/ToolUpdateCommandParser.cs
index b56ec43dccc2..deb6203fd1b4 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/update/ToolUpdateCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/update/ToolUpdateCommandParser.cs
@@ -10,27 +10,27 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class ToolUpdateCommandParser
     {
-        public static readonly CliArgument<string> PackageIdArgument = new("packageId")
+        public static readonly Argument<string> PackageIdArgument = new("packageId")
         {
             HelpName = LocalizableStrings.PackageIdArgumentName,
             Description = LocalizableStrings.PackageIdArgumentDescription,
             Arity = ArgumentArity.ZeroOrOne
         };
 
-        public static readonly CliOption<bool> UpdateAllOption = ToolAppliedOption.UpdateAllOption;
+        public static readonly Option<bool> UpdateAllOption = ToolAppliedOption.UpdateAllOption;
 
-        public static readonly CliOption<bool> AllowPackageDowngradeOption = ToolInstallCommandParser.AllowPackageDowngradeOption;
+        public static readonly Option<bool> AllowPackageDowngradeOption = ToolInstallCommandParser.AllowPackageDowngradeOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("update", LocalizableStrings.CommandDescription);
+            Command command = new("update", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(PackageIdArgument);
 
diff --git a/src/Cli/dotnet/commands/dotnet-vstest/VSTestCommandParser.cs b/src/Cli/dotnet/commands/dotnet-vstest/VSTestCommandParser.cs
index 3309cdc8385e..8715f8c073c1 100644
--- a/src/Cli/dotnet/commands/dotnet-vstest/VSTestCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-vstest/VSTestCommandParser.cs
@@ -10,14 +10,14 @@ internal static class VSTestCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-vstest";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("vstest", DocsLink)
             {
diff --git a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandBase.cs b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandBase.cs
index fefcc761f966..1fb92dd9de4e 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandBase.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandBase.cs
@@ -84,7 +84,7 @@ protected bool VerifySignatures
         /// <param name="nugetPackageDownloader">The package downloader to use for acquiring NuGet packages.</param>
         public WorkloadCommandBase(
             ParseResult parseResult,
-            CliOption<VerbosityOptions> verbosityOptions = null,
+            Option<VerbosityOptions> verbosityOptions = null,
             IReporter? reporter = null,
             string tempDirPath = null,
             INuGetPackageDownloader nugetPackageDownloader = null) : base(parseResult)
diff --git a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandNuGetRestoreActionConfigOptions.cs b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandNuGetRestoreActionConfigOptions.cs
index 337aaaa313a8..4dfad64ea0be 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandNuGetRestoreActionConfigOptions.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandNuGetRestoreActionConfigOptions.cs
@@ -10,53 +10,53 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadCommandNuGetRestoreActionConfigOptions
     {
-        public static CliOption<bool> DisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
+        public static Option<bool> DisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
         {
             Description = LocalizableStrings.CmdDisableParallelOptionDescription
         };
 
-        public static CliOption<bool> NoCacheOption = new ForwardedOption<bool>("--no-cache")
+        public static Option<bool> NoCacheOption = new ForwardedOption<bool>("--no-cache")
         {
             Description = LocalizableStrings.CmdNoCacheOptionDescription,
             Hidden = true
         };
 
-        public static CliOption<bool> NoHttpCacheOption = new ForwardedOption<bool>("--no-http-cache")
+        public static Option<bool> NoHttpCacheOption = new ForwardedOption<bool>("--no-http-cache")
         {
             Description = LocalizableStrings.CmdNoCacheOptionDescription,
         };
 
-        public static CliOption<bool> IgnoreFailedSourcesOption = new ForwardedOption<bool>("--ignore-failed-sources")
+        public static Option<bool> IgnoreFailedSourcesOption = new ForwardedOption<bool>("--ignore-failed-sources")
         {
             Description = LocalizableStrings.CmdIgnoreFailedSourcesOptionDescription
         };
 
-        public static CliOption<bool> InteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
+        public static Option<bool> InteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
         {
             Description = CommonLocalizableStrings.CommandInteractiveOptionDescription
         };
 
-        public static CliOption<bool> HiddenDisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
+        public static Option<bool> HiddenDisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
         {
             Description = LocalizableStrings.CmdDisableParallelOptionDescription
         }.Hide();
 
-        public static CliOption<bool> HiddenNoCacheOption = new ForwardedOption<bool>("--no-cache")
+        public static Option<bool> HiddenNoCacheOption = new ForwardedOption<bool>("--no-cache")
         {
             Description = LocalizableStrings.CmdNoCacheOptionDescription
         }.Hide();
 
-        public static CliOption<bool> HiddenNoHttpCacheOption = new ForwardedOption<bool>("--no-http-cache")
+        public static Option<bool> HiddenNoHttpCacheOption = new ForwardedOption<bool>("--no-http-cache")
         {
             Description = LocalizableStrings.CmdNoCacheOptionDescription
         }.Hide();
 
-        public static CliOption<bool> HiddenIgnoreFailedSourcesOption = new ForwardedOption<bool>("--ignore-failed-sources")
+        public static Option<bool> HiddenIgnoreFailedSourcesOption = new ForwardedOption<bool>("--ignore-failed-sources")
         {
             Description = LocalizableStrings.CmdIgnoreFailedSourcesOptionDescription
         }.Hide();
 
-        public static CliOption<bool> HiddenInteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
+        public static Option<bool> HiddenInteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
         {
             Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
         }.Hide();
@@ -69,7 +69,7 @@ public static RestoreActionConfig ToRestoreActionConfig(this ParseResult parseRe
                 Interactive: parseResult.GetValue(InteractiveRestoreOption));
         }
 
-        public static void AddWorkloadCommandNuGetRestoreActionConfigOptions(this CliCommand command, bool Hide = false)
+        public static void AddWorkloadCommandNuGetRestoreActionConfigOptions(this Command command, bool Hide = false)
         {
             command.Options.Add(Hide ? HiddenDisableParallelOption : DisableParallelOption);
             command.Options.Add(Hide ? HiddenIgnoreFailedSourcesOption : IgnoreFailedSourcesOption);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs
index 3234ee07b86b..f2e422490cc6 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandParser.cs
@@ -9,6 +9,7 @@
 using Microsoft.TemplateEngine.Cli.Commands;
 using CommonStrings = Microsoft.DotNet.Workloads.Workload.LocalizableStrings;
 using IReporter = Microsoft.DotNet.Cli.Utils.IReporter;
+using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -16,19 +17,19 @@ internal static class WorkloadCommandParser
     {
         public static readonly string DocsLink = "https://aka.ms/dotnet-workload";
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static readonly CliOption<bool> InfoOption = new("--info")
+        public static readonly Option<bool> InfoOption = new("--info")
         {
             Description = CommonStrings.WorkloadInfoDescription
         };
 
-        public static readonly CliOption<bool> VersionOption = new("--version")
+        public static readonly Option<bool> VersionOption = new("--version")
         {
             Description = CommonStrings.WorkloadVersionDescription
         };
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             Command.Options.Add(InfoOption);
             Command.Options.Add(VersionOption);
@@ -139,7 +140,7 @@ private static int ProcessArgs(ParseResult parseResult)
             return parseResult.HandleMissingCommand();
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             DocumentedCommand command = new("workload", DocsLink, CommonStrings.CommandDescription);
 
diff --git a/src/Cli/dotnet/commands/dotnet-workload/clean/WorkloadCleanCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/clean/WorkloadCleanCommandParser.cs
index 338da6f67dd4..c837bb9fce75 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/clean/WorkloadCleanCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/clean/WorkloadCleanCommandParser.cs
@@ -9,18 +9,18 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadCleanCommandParser
     {
-        public static readonly CliOption<bool> CleanAllOption = new("--all") { Description = LocalizableStrings.CleanAllOptionDescription };
+        public static readonly Option<bool> CleanAllOption = new("--all") { Description = LocalizableStrings.CleanAllOptionDescription };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("clean", LocalizableStrings.CommandDescription);
+            Command command = new("clean", LocalizableStrings.CommandDescription);
 
             command.Options.Add(CleanAllOption);
 
diff --git a/src/Cli/dotnet/commands/dotnet-workload/config/WorkloadConfigCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/config/WorkloadConfigCommandParser.cs
index 22114beef478..85ac95871101 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/config/WorkloadConfigCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/config/WorkloadConfigCommandParser.cs
@@ -13,24 +13,24 @@ internal static class WorkloadConfigCommandParser
         public static readonly string UpdateMode_WorkloadSet = "workload-set";
         public static readonly string UpdateMode_Manifests = "manifests";
 
-        public static readonly CliOption<string> UpdateMode = new("--update-mode")
+        public static readonly Option<string> UpdateMode = new("--update-mode")
         {
             Description = LocalizableStrings.UpdateModeDescription,
             Arity = ArgumentArity.ZeroOrOne
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
             UpdateMode.AcceptOnlyFromAmong(UpdateMode_WorkloadSet, UpdateMode_Manifests);
 
-            CliCommand command = new("config", LocalizableStrings.CommandDescription);
+            Command command = new("config", LocalizableStrings.CommandDescription);
             command.Options.Add(UpdateMode);
 
             command.SetAction(parseResult =>
diff --git a/src/Cli/dotnet/commands/dotnet-workload/elevate/WorkloadElevateCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/elevate/WorkloadElevateCommandParser.cs
index acfaf3c71e13..d4b9d79f9c86 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/elevate/WorkloadElevateCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/elevate/WorkloadElevateCommandParser.cs
@@ -9,16 +9,16 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadElevateCommandParser
     {
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("elevate", LocalizableStrings.CommandDescription)
+            Command command = new("elevate", LocalizableStrings.CommandDescription)
             {
                 Hidden = true
             };
diff --git a/src/Cli/dotnet/commands/dotnet-workload/history/WorkloadHistoryCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/history/WorkloadHistoryCommandParser.cs
index 2cc9e909eb02..34d2f4a5d87e 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/history/WorkloadHistoryCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/history/WorkloadHistoryCommandParser.cs
@@ -8,16 +8,16 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadHistoryCommandParser
     {
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("history", LocalizableStrings.CommandDescription);
+            var command = new Command("history", LocalizableStrings.CommandDescription);
 
             command.SetAction(parseResult => new WorkloadHistoryCommand(parseResult).Execute());
 
diff --git a/src/Cli/dotnet/commands/dotnet-workload/install/WorkloadInstallCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/install/WorkloadInstallCommandParser.cs
index f0323853dd79..e1a3565ee463 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/install/WorkloadInstallCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/install/WorkloadInstallCommandParser.cs
@@ -10,39 +10,39 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadInstallCommandParser
     {
-        public static readonly CliArgument<IEnumerable<string>> WorkloadIdArgument = new("workloadId")
+        public static readonly Argument<IEnumerable<string>> WorkloadIdArgument = new("workloadId")
         {
             HelpName = LocalizableStrings.WorkloadIdArgumentName,
             Arity = ArgumentArity.OneOrMore,
             Description = LocalizableStrings.WorkloadIdArgumentDescription
         };
 
-        public static readonly CliOption<bool> SkipSignCheckOption = new("--skip-sign-check")
+        public static readonly Option<bool> SkipSignCheckOption = new("--skip-sign-check")
         {
             Description = LocalizableStrings.SkipSignCheckOptionDescription,
             Hidden = true
         };
 
-        public static readonly CliOption<bool> SkipManifestUpdateOption = new("--skip-manifest-update")
+        public static readonly Option<bool> SkipManifestUpdateOption = new("--skip-manifest-update")
         {
             Description = LocalizableStrings.SkipManifestUpdateOptionDescription
         };
 
-        public static readonly CliOption<string> TempDirOption = new("--temp-dir")
+        public static readonly Option<string> TempDirOption = new("--temp-dir")
         {
             Description = LocalizableStrings.TempDirOptionDescription
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("install", LocalizableStrings.CommandDescription);
+            Command command = new("install", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(WorkloadIdArgument);
             AddWorkloadInstallCommandOptions(command);
@@ -52,7 +52,7 @@ private static CliCommand ConstructCommand()
             return command;
         }
 
-        internal static void AddWorkloadInstallCommandOptions(CliCommand command)
+        internal static void AddWorkloadInstallCommandOptions(Command command)
         {
             InstallingWorkloadCommandParser.AddWorkloadInstallCommandOptions(command);
 
diff --git a/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommandParser.cs
index ca07fc062a09..b12c8588f07f 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/list/WorkloadListCommandParser.cs
@@ -11,30 +11,30 @@ namespace Microsoft.DotNet.Cli
     internal static class WorkloadListCommandParser
     {
         // arguments are a list of workload to be detected
-        public static readonly CliOption<bool> MachineReadableOption = new("--machine-readable") { Hidden = true };
+        public static readonly Option<bool> MachineReadableOption = new("--machine-readable") { Hidden = true };
 
-        public static readonly CliOption<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
+        public static readonly Option<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
 
-        public static readonly CliOption<string> TempDirOption = new CliOption<string>("--temp-dir")
+        public static readonly Option<string> TempDirOption = new Option<string>("--temp-dir")
         {
             Description = Workloads.Workload.Install.LocalizableStrings.TempDirOptionDescription
         }.Hide();
 
-        public static readonly CliOption<bool> IncludePreviewsOption = new CliOption<bool>("--include-previews")
+        public static readonly Option<bool> IncludePreviewsOption = new Option<bool>("--include-previews")
         {
             Description = Workloads.Workload.Install.LocalizableStrings.IncludePreviewOptionDescription
         }.Hide();
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("list", LocalizableStrings.CommandDescription);
+            Command command = new("list", LocalizableStrings.CommandDescription);
             command.Options.Add(MachineReadableOption);
             command.Options.Add(CommonOptions.HiddenVerbosityOption);
             command.Options.Add(VersionOption);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/repair/WorkloadRepairCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/repair/WorkloadRepairCommandParser.cs
index 3b33204552c8..4f0c62880d78 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/repair/WorkloadRepairCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/repair/WorkloadRepairCommandParser.cs
@@ -10,22 +10,22 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadRepairCommandParser
     {
-        public static readonly CliOption<string> ConfigOption = InstallingWorkloadCommandParser.ConfigOption;
+        public static readonly Option<string> ConfigOption = InstallingWorkloadCommandParser.ConfigOption;
 
-        public static readonly CliOption<string[]> SourceOption = InstallingWorkloadCommandParser.SourceOption;
+        public static readonly Option<string[]> SourceOption = InstallingWorkloadCommandParser.SourceOption;
 
-        public static readonly CliOption<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
+        public static readonly Option<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("repair", LocalizableStrings.CommandDescription);
+            Command command = new("repair", LocalizableStrings.CommandDescription);
 
             command.Options.Add(VersionOption);
             command.Options.Add(ConfigOption);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/restore/WorkloadRestoreCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/restore/WorkloadRestoreCommandParser.cs
index 9308620fab7f..e4ba8e581844 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/restore/WorkloadRestoreCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/restore/WorkloadRestoreCommandParser.cs
@@ -9,16 +9,16 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadRestoreCommandParser
     {
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("restore", LocalizableStrings.CommandDescription);
+            Command command = new("restore", LocalizableStrings.CommandDescription);
 
             command.Arguments.Add(RestoreCommandParser.SlnOrProjectArgument);
             WorkloadInstallCommandParser.AddWorkloadInstallCommandOptions(command);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchCommandParser.cs
index 3c4cc66b5391..4eb1cbc62029 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchCommandParser.cs
@@ -10,25 +10,25 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadSearchCommandParser
     {
-        public static readonly CliArgument<string> WorkloadIdStubArgument =
+        public static readonly Argument<string> WorkloadIdStubArgument =
             new(LocalizableStrings.WorkloadIdStubArgumentName)
             {
                 Arity = ArgumentArity.ZeroOrOne,
                 Description = LocalizableStrings.WorkloadIdStubArgumentDescription
             };
 
-        public static readonly CliOption<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
+        public static readonly Option<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("search", LocalizableStrings.CommandDescription);
+            var command = new Command("search", LocalizableStrings.CommandDescription);
             command.Subcommands.Add(WorkloadSearchVersionsCommandParser.GetCommand());
             command.Arguments.Add(WorkloadIdStubArgument);
             command.Options.Add(CommonOptions.HiddenVerbosityOption);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchVersionsCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchVersionsCommandParser.cs
index b733f0e01a93..a3835da079ad 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchVersionsCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/search/WorkloadSearchVersionsCommandParser.cs
@@ -10,32 +10,32 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadSearchVersionsCommandParser
     {
-        public static readonly CliArgument<string> WorkloadVersionArgument =
+        public static readonly Argument<string> WorkloadVersionArgument =
             new(LocalizableStrings.WorkloadVersionArgument)
             {
                 Arity = ArgumentArity.ZeroOrOne,
                 Description = LocalizableStrings.WorkloadVersionArgumentDescription
             };
 
-        public static readonly CliOption<int> TakeOption = new("--take") { DefaultValueFactory = (_) => 5 };
+        public static readonly Option<int> TakeOption = new("--take") { DefaultValueFactory = (_) => 5 };
 
-        public static readonly CliOption<string> FormatOption = new("--format")
+        public static readonly Option<string> FormatOption = new("--format")
         {
             Description = LocalizableStrings.FormatOptionDescription
         };
 
-        public static readonly CliOption<bool> IncludePreviewsOption = new("--include-previews");
+        public static readonly Option<bool> IncludePreviewsOption = new("--include-previews");
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            var command = new CliCommand("version", LocalizableStrings.PrintSetVersionsDescription);
+            var command = new Command("version", LocalizableStrings.PrintSetVersionsDescription);
             command.Arguments.Add(WorkloadVersionArgument);
             command.Options.Add(FormatOption);
             command.Options.Add(TakeOption);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/uninstall/WorkloadUninstallCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/uninstall/WorkloadUninstallCommandParser.cs
index 5e914b7d3a99..76c05c617ad9 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/uninstall/WorkloadUninstallCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/uninstall/WorkloadUninstallCommandParser.cs
@@ -10,20 +10,20 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadUninstallCommandParser
     {
-        public static readonly CliArgument<IEnumerable<string>> WorkloadIdArgument = WorkloadInstallCommandParser.WorkloadIdArgument;
+        public static readonly Argument<IEnumerable<string>> WorkloadIdArgument = WorkloadInstallCommandParser.WorkloadIdArgument;
 
-        public static readonly CliOption<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
+        public static readonly Option<string> VersionOption = InstallingWorkloadCommandParser.VersionOption;
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("uninstall", LocalizableStrings.CommandDescription);
+            Command command = new("uninstall", LocalizableStrings.CommandDescription);
             command.Arguments.Add(WorkloadIdArgument);
             command.Options.Add(WorkloadInstallCommandParser.SkipSignCheckOption);
             command.Options.Add(CommonOptions.VerbosityOption);
diff --git a/src/Cli/dotnet/commands/dotnet-workload/update/WorkloadUpdateCommandParser.cs b/src/Cli/dotnet/commands/dotnet-workload/update/WorkloadUpdateCommandParser.cs
index 28f142fee4f4..a648ad9e0ddd 100644
--- a/src/Cli/dotnet/commands/dotnet-workload/update/WorkloadUpdateCommandParser.cs
+++ b/src/Cli/dotnet/commands/dotnet-workload/update/WorkloadUpdateCommandParser.cs
@@ -10,43 +10,43 @@ namespace Microsoft.DotNet.Cli
 {
     internal static class WorkloadUpdateCommandParser
     {
-        public static readonly CliOption<string> TempDirOption = WorkloadInstallCommandParser.TempDirOption;
+        public static readonly Option<string> TempDirOption = WorkloadInstallCommandParser.TempDirOption;
 
-        public static readonly CliOption<bool> FromPreviousSdkOption = new("--from-previous-sdk")
+        public static readonly Option<bool> FromPreviousSdkOption = new("--from-previous-sdk")
         {
             Description = LocalizableStrings.FromPreviousSdkOptionDescription
         };
 
-        public static readonly CliOption<bool> AdManifestOnlyOption = new("--advertising-manifests-only")
+        public static readonly Option<bool> AdManifestOnlyOption = new("--advertising-manifests-only")
         {
             Description = LocalizableStrings.AdManifestOnlyOptionDescription
         };
 
-        public static readonly CliOption<bool> PrintRollbackOption = new("--print-rollback")
+        public static readonly Option<bool> PrintRollbackOption = new("--print-rollback")
         {
             Hidden = true
         };
 
-        public static readonly CliOption<int> FromHistoryOption = new("--from-history")
+        public static readonly Option<int> FromHistoryOption = new("--from-history")
         {
             Description = LocalizableStrings.FromHistoryOptionDescription
         };
 
-        public static readonly CliOption<string> HistoryManifestOnlyOption = new("--manifests-only")
+        public static readonly Option<string> HistoryManifestOnlyOption = new("--manifests-only")
         {
             Description = LocalizableStrings.HistoryManifestOnlyOptionDescription
         };
 
-        private static readonly CliCommand Command = ConstructCommand();
+        private static readonly Command Command = ConstructCommand();
 
-        public static CliCommand GetCommand()
+        public static Command GetCommand()
         {
             return Command;
         }
 
-        private static CliCommand ConstructCommand()
+        private static Command ConstructCommand()
         {
-            CliCommand command = new("update", LocalizableStrings.CommandDescription);
+            Command command = new("update", LocalizableStrings.CommandDescription);
 
             InstallingWorkloadCommandParser.AddWorkloadInstallCommandOptions(command);
 
diff --git a/src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompat.Tool/Program.cs b/src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompat.Tool/Program.cs
index 1cf403f061f1..4d1f8e416df8 100644
--- a/src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompat.Tool/Program.cs
+++ b/src/Compatibility/ApiCompat/Microsoft.DotNet.ApiCompat.Tool/Program.cs
@@ -19,22 +19,22 @@ static int Main(string[] args)
             // Important: Keep parameters exposed in sync with the msbuild task frontend.
 
             // Global options
-            CliOption<bool> generateSuppressionFileOption = new("--generate-suppression-file")
+            Option<bool> generateSuppressionFileOption = new("--generate-suppression-file")
             {
                 Description = "If true, generates a compatibility suppression file.",
                 Recursive = true
             };
-            CliOption<bool> preserveUnnecessarySuppressionsOption = new("--preserve-unnecessary-suppressions")
+            Option<bool> preserveUnnecessarySuppressionsOption = new("--preserve-unnecessary-suppressions")
             {
                 Description = "If true, preserves unnecessary suppressions when re-generating the suppression file.",
                 Recursive = true
             };
-            CliOption<bool> permitUnnecessarySuppressionsOption = new("--permit-unnecessary-suppressions")
+            Option<bool> permitUnnecessarySuppressionsOption = new("--permit-unnecessary-suppressions")
             {
                 Description = "If true, permits unnecessary suppressions in the suppression file.",
                 Recursive = true
             };
-            CliOption<string[]> suppressionFilesOption = new("--suppression-file")
+            Option<string[]> suppressionFilesOption = new("--suppression-file")
             {
                 Description = "The path to one or more suppression files to read from.",
                 AllowMultipleArgumentsPerToken = true,
@@ -42,51 +42,51 @@ static int Main(string[] args)
                 HelpName = "file",
                 Recursive = true
             };
-            CliOption<string?> suppressionOutputFileOption = new("--suppression-output-file")
+            Option<string?> suppressionOutputFileOption = new("--suppression-output-file")
             {
                 Description = "The path to a suppression file to write to when --generate-suppression-file is true.",
                 Recursive = true
             };
-            CliOption<string?> noWarnOption = new("--noWarn")
+            Option<string?> noWarnOption = new("--noWarn")
             {
                 Description = "A NoWarn string that allows to disable specific rules.",
                 Recursive = true
             };
-            CliOption<bool> respectInternalsOption = new("--respect-internals")
+            Option<bool> respectInternalsOption = new("--respect-internals")
             {
                 Description = "If true, includes both internal and public API.",
                 Recursive = true
             };
-            CliOption<string?> roslynAssembliesPathOption = new("--roslyn-assemblies-path")
+            Option<string?> roslynAssembliesPathOption = new("--roslyn-assemblies-path")
             {
                 Description = "The path to the directory that contains the Microsoft.CodeAnalysis assemblies.",
                 HelpName = "file",
                 Recursive = true
             };
-            CliOption<MessageImportance> verbosityOption = new("--verbosity", "-v")
+            Option<MessageImportance> verbosityOption = new("--verbosity", "-v")
             {
                 Description = "Controls the log level verbosity. Allowed values are high, normal, and low.",
                 DefaultValueFactory = _ => MessageImportance.Normal,
                 Recursive = true
             };
-            CliOption<bool> enableRuleAttributesMustMatchOption = new("--enable-rule-attributes-must-match")
+            Option<bool> enableRuleAttributesMustMatchOption = new("--enable-rule-attributes-must-match")
             {
                 Description = "If true, enables rule to check that attributes match.",
                 Recursive = true
             };
-            CliOption<string[]> excludeAttributesFilesOption = new("--exclude-attributes-file")
+            Option<string[]> excludeAttributesFilesOption = new("--exclude-attributes-file")
             {
                 Description = "The path to one or more attribute exclusion files with types in DocId format.",
                 Recursive = true
             };
-            CliOption<bool> enableRuleCannotChangeParameterNameOption = new("--enable-rule-cannot-change-parameter-name")
+            Option<bool> enableRuleCannotChangeParameterNameOption = new("--enable-rule-cannot-change-parameter-name")
             {
                 Description = "If true, enables rule to check that the parameter names between public methods do not change.",
                 Recursive = true
             };
 
             // Root command
-            CliOption<string[]> leftAssembliesOption = new("--left-assembly", "--left", "-l")
+            Option<string[]> leftAssembliesOption = new("--left-assembly", "--left", "-l")
             {
                 Description = "The path to one or more assemblies that serve as the left side to compare.",
                 CustomParser = ParseAssemblyArgument,
@@ -94,7 +94,7 @@ static int Main(string[] args)
                 Arity = ArgumentArity.OneOrMore,
                 Required = true
             };
-            CliOption<string[]> rightAssembliesOption = new("--right-assembly", "--right", "-r")
+            Option<string[]> rightAssembliesOption = new("--right-assembly", "--right", "-r")
             {
                 Description = "The path to one or more assemblies that serve as the right side to compare.",
                 CustomParser = ParseAssemblyArgument,
@@ -102,11 +102,11 @@ static int Main(string[] args)
                 Arity = ArgumentArity.OneOrMore,
                 Required = true
             };
-            CliOption<bool> strictModeOption = new("--strict-mode")
+            Option<bool> strictModeOption = new("--strict-mode")
             {
                 Description = "If true, performs api compatibility checks in strict mode"
             };
-            CliOption<string[][]?> leftAssembliesReferencesOption = new("--left-assembly-references", "--lref")
+            Option<string[][]?> leftAssembliesReferencesOption = new("--left-assembly-references", "--lref")
 
             {
                 Description = "Paths to assembly references or the underlying directories for a given left. Values must be separated by commas: ','.",
@@ -115,7 +115,7 @@ static int Main(string[] args)
                 Arity = ArgumentArity.ZeroOrMore,
                 HelpName = "file1,file2,..."
             };
-            CliOption<string[][]?> rightAssembliesReferencesOption = new("--right-assembly-references", "--rref")
+            Option<string[][]?> rightAssembliesReferencesOption = new("--right-assembly-references", "--rref")
             {
                 Description = "Paths to assembly references or the underlying directories for a given right. Values must be separated by commas: ','.",
                 CustomParser = ParseAssemblyReferenceArgument,
@@ -123,18 +123,18 @@ static int Main(string[] args)
                 Arity = ArgumentArity.ZeroOrMore,
                 HelpName = "file1,file2,..."
             };
-            CliOption<bool> createWorkItemPerAssemblyOption = new("--create-work-item-per-assembly")
+            Option<bool> createWorkItemPerAssemblyOption = new("--create-work-item-per-assembly")
             {
                 Description = "If true, enqueues a work item per passed in left and right assembly."
             };
-            CliOption<(string, string)[]?> leftAssembliesTransformationPatternOption = new("--left-assemblies-transformation-pattern")
+            Option<(string, string)[]?> leftAssembliesTransformationPatternOption = new("--left-assemblies-transformation-pattern")
             {
                 Description = "A transformation pattern for the left side assemblies.",
                 CustomParser = ParseTransformationPattern,
                 AllowMultipleArgumentsPerToken = true,
                 Arity = ArgumentArity.ZeroOrMore
             };
-            CliOption<(string, string)[]?> rightAssembliesTransformationPatternOption = new("--right-assemblies-transformation-pattern")
+            Option<(string, string)[]?> rightAssembliesTransformationPatternOption = new("--right-assemblies-transformation-pattern")
             {
                 Description = "A transformation pattern for the right side assemblies.",
                 CustomParser = ParseTransformationPattern,
@@ -142,7 +142,7 @@ static int Main(string[] args)
                 Arity = ArgumentArity.ZeroOrMore
             };
 
-            CliRootCommand rootCommand = new("Microsoft.DotNet.ApiCompat v" + FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion)
+            RootCommand rootCommand = new("Microsoft.DotNet.ApiCompat v" + FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion)
             {
                 TreatUnmatchedTokensAsErrors = true
             };
@@ -223,40 +223,40 @@ static int Main(string[] args)
             });
 
             // Package command
-            CliArgument<string> packageArgument = new("--package")
+            Argument<string> packageArgument = new("--package")
             {
                 Description = "The path to the package that should be validated",
                 Arity = ArgumentArity.ExactlyOne
             };
-            CliOption<string?> runtimeGraphOption = new("--runtime-graph")
+            Option<string?> runtimeGraphOption = new("--runtime-graph")
             {
                 Description = "The path to the runtime graph to read from.",
                 HelpName = "json"
             };
-            CliOption<bool> runApiCompatOption = new("--run-api-compat")
+            Option<bool> runApiCompatOption = new("--run-api-compat")
             {
                 Description = "If true, performs api compatibility checks on the package assets.",
                 DefaultValueFactory = _ => true
             };
-            CliOption<bool> enableStrictModeForCompatibleTfmsOption = new("--enable-strict-mode-for-compatible-tfms")
+            Option<bool> enableStrictModeForCompatibleTfmsOption = new("--enable-strict-mode-for-compatible-tfms")
             {
                 Description = "Validates api compatibility in strict mode for contract and implementation assemblies for all compatible target frameworks.",
                 DefaultValueFactory = _ => true
             };
-            CliOption<bool> enableStrictModeForCompatibleFrameworksInPackageOption = new("--enable-strict-mode-for-compatible-frameworks-in-package")
+            Option<bool> enableStrictModeForCompatibleFrameworksInPackageOption = new("--enable-strict-mode-for-compatible-frameworks-in-package")
             {
                 Description = "Validates api compatibility in strict mode for assemblies that are compatible based on their target framework."
             };
-            CliOption<bool> enableStrictModeForBaselineValidationOption = new("--enable-strict-mode-for-baseline-validation")
+            Option<bool> enableStrictModeForBaselineValidationOption = new("--enable-strict-mode-for-baseline-validation")
             {
                 Description = "Validates api compatibility in strict mode for package baseline checks."
             };
-            CliOption<string?> baselinePackageOption = new("--baseline-package")
+            Option<string?> baselinePackageOption = new("--baseline-package")
             {
                 Description = "The path to a baseline package to validate against the current package.",
                 HelpName = "nupkg"
             };
-            CliOption<Dictionary<NuGetFramework, IEnumerable<string>>?> packageAssemblyReferencesOption = new("--package-assembly-references")
+            Option<Dictionary<NuGetFramework, IEnumerable<string>>?> packageAssemblyReferencesOption = new("--package-assembly-references")
             {
                 Description = "Paths to assembly references or their underlying directories for a specific target framework in the package. Values must be separated by commas: ','.",
                 CustomParser = ParsePackageAssemblyReferenceArgument,
@@ -264,7 +264,7 @@ static int Main(string[] args)
                 Arity = ArgumentArity.ZeroOrMore,
                 HelpName = "tfm=file1,file2,..."
             };
-            CliOption<Dictionary<NuGetFramework, IEnumerable<string>>?> baselinePackageAssemblyReferencesOption = new("--baseline-package-assembly-references")
+            Option<Dictionary<NuGetFramework, IEnumerable<string>>?> baselinePackageAssemblyReferencesOption = new("--baseline-package-assembly-references")
             {
                 Description = "Paths to assembly references or their underlying directories for a specific target framework in the baseline package. Values must be separated by commas: ','.",
                 CustomParser = ParsePackageAssemblyReferenceArgument,
@@ -272,14 +272,14 @@ static int Main(string[] args)
                 Arity = ArgumentArity.ZeroOrMore,
                 HelpName = "tfm=file1,file2,..."
             };
-            CliOption<string[]?> baselinePackageFrameworksToIgnoreOption = new("--baseline-package-frameworks-to-ignore")
+            Option<string[]?> baselinePackageFrameworksToIgnoreOption = new("--baseline-package-frameworks-to-ignore")
             {
                 Description = "Target frameworks to ignore from the baseline package. Supports the wildcard character '*' at the end of the string. Culture and casing is ignored. The framework string must match the folder name in the baseline package.",
                 AllowMultipleArgumentsPerToken = true,
                 Arity = ArgumentArity.ZeroOrMore
             };
 
-            CliCommand packageCommand = new("package", "Validates the compatibility of package assets");
+            Command packageCommand = new("package", "Validates the compatibility of package assets");
             packageCommand.Arguments.Add(packageArgument);
             packageCommand.Options.Add(runtimeGraphOption);
             packageCommand.Options.Add(runApiCompatOption);
diff --git a/src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI.Tool/Program.cs b/src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI.Tool/Program.cs
index dd2edbcbbd94..2a04c2ad95fc 100644
--- a/src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI.Tool/Program.cs
+++ b/src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI.Tool/Program.cs
@@ -17,7 +17,7 @@ class Program
         static int Main(string[] args)
         {
             // Global options
-            CliOption<string[]> assembliesOption = new("--assembly")
+            Option<string[]> assembliesOption = new("--assembly")
             {
                 Description = "The path to one or more assemblies or directories with assemblies.",
                 CustomParser = ParseAssemblyArgument,
@@ -26,7 +26,7 @@ static int Main(string[] args)
                 Recursive = true
             };
 
-            CliOption<string[]?> assemblyReferencesOption = new("--assembly-reference")
+            Option<string[]?> assemblyReferencesOption = new("--assembly-reference")
             {
                 Description = "Paths to assembly references or their underlying directories for a specific target framework in the package.",
                 CustomParser = ParseAssemblyArgument,
@@ -34,7 +34,7 @@ static int Main(string[] args)
                 Recursive = true
             };
 
-            CliOption<string[]?> excludeApiFilesOption = new("--exclude-api-file")
+            Option<string[]?> excludeApiFilesOption = new("--exclude-api-file")
             {
                 Description = "The path to one or more api exclusion files with types in DocId format.",
                 CustomParser = ParseAssemblyArgument,
@@ -42,7 +42,7 @@ static int Main(string[] args)
                 Recursive = true
             };
 
-            CliOption<string[]?> excludeAttributesFilesOption = new("--exclude-attributes-file")
+            Option<string[]?> excludeAttributesFilesOption = new("--exclude-attributes-file")
             {
                 Description = "The path to one or more attribute exclusion files with types in DocId format.",
                 CustomParser = ParseAssemblyArgument,
@@ -50,37 +50,37 @@ static int Main(string[] args)
                 Recursive = true
             };
 
-            CliOption<string?> outputPathOption = new("--output-path")
+            Option<string?> outputPathOption = new("--output-path")
             {
                 Description = @"Output path. Default is the console. Can specify an existing directory as well
             and then a file will be created for each assembly with the matching name of the assembly.",
                 Recursive = true
             };
 
-            CliOption<string?> headerFileOption = new("--header-file")
+            Option<string?> headerFileOption = new("--header-file")
             {
                 Description = "Specify a file with an alternate header content to prepend to output.",
                 Recursive = true
             };
 
-            CliOption<string?> exceptionMessageOption = new("--exception-message")
+            Option<string?> exceptionMessageOption = new("--exception-message")
             {
                 Description = "If specified - method bodies should throw PlatformNotSupportedException, else `throw null`.",
                 Recursive = true
             };
 
-            CliOption<bool> respectInternalsOption = new("--respect-internals")
+            Option<bool> respectInternalsOption = new("--respect-internals")
             {
                 Description = "If true, includes both internal and public API.",
                 Recursive = true
             };
 
-            CliOption<bool> includeAssemblyAttributesOption = new("--include-assembly-attributes")
+            Option<bool> includeAssemblyAttributesOption = new("--include-assembly-attributes")
             {
                 Description = "Includes assembly attributes which are values that provide information about an assembly. Default is false."
             };
 
-            CliRootCommand rootCommand = new("Microsoft.DotNet.GenAPI v" + FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion)
+            RootCommand rootCommand = new("Microsoft.DotNet.GenAPI v" + FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion)
             {
                 TreatUnmatchedTokensAsErrors = true
             };
diff --git a/src/Containers/containerize/ContainerizeCommand.cs b/src/Containers/containerize/ContainerizeCommand.cs
index 612b589ba7fd..8da04309a921 100644
--- a/src/Containers/containerize/ContainerizeCommand.cs
+++ b/src/Containers/containerize/ContainerizeCommand.cs
@@ -10,115 +10,115 @@
 
 namespace containerize;
 
-internal class ContainerizeCommand : CliRootCommand
+internal class ContainerizeCommand : RootCommand
 {
-    internal CliArgument<DirectoryInfo> PublishDirectoryArgument { get; } = new CliArgument<DirectoryInfo>("PublishDirectory")
+    internal Argument<DirectoryInfo> PublishDirectoryArgument { get; } = new Argument<DirectoryInfo>("PublishDirectory")
     {
         Description = "The directory for the build outputs to be published."
     }.AcceptExistingOnly();
 
-    internal CliOption<string> BaseRegistryOption { get; } = new("--baseregistry")
+    internal Option<string> BaseRegistryOption { get; } = new("--baseregistry")
     {
         Description = "The registry to use for the base image.",
         Required = true
     };
 
-    internal CliOption<string> BaseImageNameOption { get; } = new("--baseimagename")
+    internal Option<string> BaseImageNameOption { get; } = new("--baseimagename")
     {
         Description = "The base image to pull.",
         Required = true
     };
 
-    internal CliOption<string> BaseImageTagOption { get; } = new("--baseimagetag")
+    internal Option<string> BaseImageTagOption { get; } = new("--baseimagetag")
     {
         Description = "The base image tag. Ex: 6.0",
         DefaultValueFactory = (_) => "latest"
     };
 
-    internal CliOption<string> BaseImageDigestOption { get; } = new("--baseimagedigest")
+    internal Option<string> BaseImageDigestOption { get; } = new("--baseimagedigest")
     {
         Description = "The base image digest. Ex: sha256:6cec3641...",
         Required = false
     };
 
-    internal CliOption<string> OutputRegistryOption { get; } = new("--outputregistry")
+    internal Option<string> OutputRegistryOption { get; } = new("--outputregistry")
     {
         Description = "The registry to push to.",
         Required = false
     };
 
-    internal CliOption<string> ArchiveOutputPathOption { get; } = new("--archiveoutputpath")
+    internal Option<string> ArchiveOutputPathOption { get; } = new("--archiveoutputpath")
     {
         Description = "The file path to which to write a tar.gz archive of the container image.",
         Required = false
     };
 
-    internal CliOption<string> RepositoryOption { get; } = new("--repository")
+    internal Option<string> RepositoryOption { get; } = new("--repository")
     {
         Description = "The name of the output container repository that will be pushed to the registry.",
         Required = true
     };
 
-    internal CliOption<string[]> ImageTagsOption { get; } = new("--imagetags")
+    internal Option<string[]> ImageTagsOption { get; } = new("--imagetags")
     {
         Description = "The tags to associate with the new image.",
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string> WorkingDirectoryOption { get; } = new("--workingdirectory")
+    internal Option<string> WorkingDirectoryOption { get; } = new("--workingdirectory")
     {
         Description = "The working directory of the container.",
         Required = true
     };
 
-    internal CliOption<string[]> EntrypointOption { get; } = new("--entrypoint")
+    internal Option<string[]> EntrypointOption { get; } = new("--entrypoint")
     {
         Description = "The entrypoint application of the container.",
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string[]> EntrypointArgsOption { get; } = new("--entrypointargs")
+    internal Option<string[]> EntrypointArgsOption { get; } = new("--entrypointargs")
     {
         Description = "Arguments to pass alongside Entrypoint.",
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string[]> DefaultArgsOption { get; } = new CliOption<string[]>("--defaultargs")
+    internal Option<string[]> DefaultArgsOption { get; } = new Option<string[]>("--defaultargs")
     {
         Description = "Default arguments passed. These can be overridden by the user when the container is created.",
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string[]> AppCommandOption { get; } = new("--appcommand")
+    internal Option<string[]> AppCommandOption { get; } = new("--appcommand")
     {
         Description = "The file name and arguments that launch the application. For example: ['dotnet', 'app.dll'].",
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string[]> AppCommandArgsOption { get; } = new("--appcommandargs")
+    internal Option<string[]> AppCommandArgsOption { get; } = new("--appcommandargs")
     {
         Description = "Arguments always passed to the application.",
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string> AppCommandInstructionOption { get; } = new CliOption<string>("--appcommandinstruction")
+    internal Option<string> AppCommandInstructionOption { get; } = new Option<string>("--appcommandinstruction")
     {
         Description = "The Dockerfile instruction used for AppCommand. Can be set to 'DefaultArgs', 'Entrypoint', 'None', '' (default)."
     };
 
-    internal CliOption<string> LocalRegistryOption { get; } = new CliOption<string>("--localregistry")
+    internal Option<string> LocalRegistryOption { get; } = new Option<string>("--localregistry")
     {
         Description = "The local registry to push to."
     };
 
-    internal CliOption<Dictionary<string, string>> LabelsOption { get; } = new("--labels")
+    internal Option<Dictionary<string, string>> LabelsOption { get; } = new("--labels")
     {
         Description = "Labels that the image configuration will include in metadata.",
         CustomParser = result => ParseDictionary(result, errorMessage: "Incorrectly formatted labels: "),
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<Port[]> PortsOption { get; } = new("--ports")
+    internal Option<Port[]> PortsOption { get; } = new("--ports")
     {
         Description = "Ports that the application declares that it will use. Note that this means nothing to container hosts, by default - it's mostly documentation. Ports should be of the form {number}/{type}, where {type} is tcp or udp",
         AllowMultipleArgumentsPerToken = true,
@@ -178,32 +178,32 @@ internal class ContainerizeCommand : CliRootCommand
         }
     };
 
-    internal CliOption<Dictionary<string, string>> EnvVarsOption { get; } = new("--environmentvariables")
+    internal Option<Dictionary<string, string>> EnvVarsOption { get; } = new("--environmentvariables")
     {
         Description = "Container environment variables to set.",
         CustomParser = result => ParseDictionary(result, errorMessage: "Incorrectly formatted environment variables:  "),
         AllowMultipleArgumentsPerToken = true
     };
 
-    internal CliOption<string> RidOption { get; } = new("--rid") { Description = "Runtime Identifier of the generated container." };
+    internal Option<string> RidOption { get; } = new("--rid") { Description = "Runtime Identifier of the generated container." };
 
-    internal CliOption<string> RidGraphPathOption { get; } = new("--ridgraphpath") { Description = "Path to the RID graph file." };
+    internal Option<string> RidGraphPathOption { get; } = new("--ridgraphpath") { Description = "Path to the RID graph file." };
 
-    internal CliOption<string> ContainerUserOption { get; } = new("--container-user") { Description = "User to run the container as." };
+    internal Option<string> ContainerUserOption { get; } = new("--container-user") { Description = "User to run the container as." };
 
-    internal CliOption<bool> GenerateLabelsOption { get; } = new("--generate-labels")
+    internal Option<bool> GenerateLabelsOption { get; } = new("--generate-labels")
     {
         Description = "If true, the tooling may create labels on the generated images.",
         Arity = ArgumentArity.Zero
     };
 
-    internal CliOption<bool> GenerateDigestLabelOption { get; } = new("--generate-digest-label")
+    internal Option<bool> GenerateDigestLabelOption { get; } = new("--generate-digest-label")
     {
         Description = "If true, the tooling will generate an 'org.opencontainers.image.base.digest' label on the generated images containing the digest of the chosen base image.",
         Arity = ArgumentArity.Zero
     };
 
-    internal CliOption<KnownImageFormats?> ImageFormatOption { get; } = new("--image-format")
+    internal Option<KnownImageFormats?> ImageFormatOption { get; } = new("--image-format")
     {
         Description = "If set to OCI or Docker will force the generated image to be that format. If unset, the base images format will be used."
     };
diff --git a/src/StaticWebAssetsSdk/Tool/Program.cs b/src/StaticWebAssetsSdk/Tool/Program.cs
index a92c5ebd1f94..9dc0fc5e4867 100644
--- a/src/StaticWebAssetsSdk/Tool/Program.cs
+++ b/src/StaticWebAssetsSdk/Tool/Program.cs
@@ -12,20 +12,20 @@ internal static class Program
 {
     public static int Main(string[] args)
     {
-        CliRootCommand rootCommand = new();
-        CliCommand brotli = new("brotli");
+        RootCommand rootCommand = new();
+        Command brotli = new("brotli");
 
-        CliOption<CompressionLevel> compressionLevelOption = new("-c")
+        Option<CompressionLevel> compressionLevelOption = new("-c")
         {
             DefaultValueFactory = (_) => CompressionLevel.SmallestSize,
             Description = "System.IO.Compression.CompressionLevel for the Brotli compression algorithm."
         };
-        CliOption<List<string>> sourcesOption = new("-s")
+        Option<List<string>> sourcesOption = new("-s")
         {
             Description = "A list of files to compress.",
             AllowMultipleArgumentsPerToken = false
         };
-        CliOption<List<string>> outputsOption = new("-o")
+        Option<List<string>> outputsOption = new("-o")
         {
             Description = "The filenames to output the compressed file to.",
             AllowMultipleArgumentsPerToken = false
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
index 8500a82ca5da..5716bc4f1b85 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
@@ -229,7 +229,7 @@ public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
index c5696cef8014..d7dbba8f2678 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
@@ -74,7 +74,7 @@ internal void Create_CanParseNameOption(string command, string? expectedValue)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Add(myCommand);
 
@@ -83,7 +83,7 @@ internal void Create_CanParseNameOption(string command, string? expectedValue)
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
             TemplateCommand templateCommand = new(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.TokensToInvoke ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, instantiateCommand, templateParseResult);
 
@@ -111,7 +111,7 @@ internal void Create_CanValidateOptionUsage_InNewCommand(string command, string?
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Add(myCommand);
 
@@ -146,7 +146,7 @@ internal void Create_CanParseTemplateOptions(string command, string parameterNam
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
             TemplateCommand templateCommand = new(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, instantiateCommand, templateParseResult);
 
@@ -181,7 +181,7 @@ internal void Create_CanParseChoiceTemplateOptions(string command, string parame
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
             TemplateCommand templateCommand = new(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, instantiateCommand, templateParseResult);
 
@@ -224,7 +224,7 @@ internal void Create_CanDetectParseErrorsTemplateOptions(
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
 
             TemplateCommand templateCommand = new(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             Assert.True(templateParseResult.Errors.Any());
             Assert.Equal(expectedError, templateParseResult.Errors.Single().Message);
@@ -258,7 +258,7 @@ internal void Create_CanDetectParseErrorsChoiceTemplateOptions(
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
 
             TemplateCommand templateCommand = new(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             Assert.True(templateParseResult.Errors.Any());
             Assert.Equal(expectedError, templateParseResult.Errors.Single().Message);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
index 641fdefe7d94..d3a0b2beeaa7 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
@@ -249,13 +249,13 @@ internal void CanParseNameOption(string command, string? expectedValue)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Subcommands.Add(myCommand);
             ParseResult parseResult = rootCommand.Parse(command);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.TokensToInvoke ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
 
@@ -317,11 +317,11 @@ internal void CanParseTemplateOptions(string command, string parameterName, stri
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliConfiguration parser = ParserFactory.CreateParser(myCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(myCommand);
             ParseResult parseResult = parser.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration templateCommandParser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration templateCommandParser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = templateCommandParser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
 
@@ -364,7 +364,7 @@ internal void CanParseChoiceTemplateOptions(string command, string parameterName
             ParseResult parseResult = myCommand.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
 
@@ -408,7 +408,7 @@ internal void CanParseMultiChoiceTemplateOptions(string command, string paramete
             ParseResult parseResult = myCommand.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
 
@@ -479,7 +479,7 @@ internal void CanDetectParseErrorsTemplateOptions(
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             Assert.True(templateParseResult.Errors.Any());
             Assert.Equal(expectedError, templateParseResult.Errors.Single().Message);
@@ -519,12 +519,12 @@ internal void CanDetectParseErrorsChoiceTemplateOptions(
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliConfiguration parser = ParserFactory.CreateParser(myCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(myCommand);
             ParseResult parseResult = parser.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration templateCommandParser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration templateCommandParser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = templateCommandParser.Parse(args.RemainingArguments ?? Array.Empty<string>());
             Assert.True(templateParseResult.Errors.Any());
             Assert.Equal(expectedError, templateParseResult.Errors.Single().Message);
@@ -548,7 +548,7 @@ internal void DoNotAddAllowScriptOptionForTemplate()
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
 
             TemplateCommandArgs templateArgs = new(templateCommand, myCommand, templateParseResult);
@@ -581,7 +581,7 @@ internal void CanParseAllowScriptsOption(string command, AllowRunScripts? result
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty<string>());
 
             TemplateCommandArgs templateArgs = new(templateCommand, myCommand, templateParseResult);
@@ -734,7 +734,7 @@ internal void CanParseFlagsOption(string command, string action)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Subcommands.Add(myCommand);
             ParseResult parseResult = rootCommand.Parse(command);
@@ -745,7 +745,7 @@ internal void CanParseFlagsOption(string command, string action)
                 templatePackageManager: packageManager,
                 templateGroup: templateGroup,
                 template: templateGroup.Templates.Single());
-            CliConfiguration parser = ParserFactory.CreateParser(templateCommand);
+            CommandLineConfiguration parser = ParserFactory.CreateParser(templateCommand);
             ParseResult templateParseResult = parser.Parse(args.TokensToInvoke ?? Array.Empty<string>());
             var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult);
 
@@ -765,7 +765,7 @@ internal void CanParse_WithoutRequiredParameter()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Subcommands.Add(myCommand);
             ParseResult parseResult = rootCommand.Parse("new foo");
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
index d3338cd7aa7f..d8f69adfdca2 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
@@ -269,7 +269,7 @@ public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
index 9a936480726e..10ad62d08119 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
@@ -18,10 +18,10 @@ public class MiscTests : BaseTest
         [Fact]
         public void KnownHelpAliasesAreCorrect()
         {
-            ParseResult result = new CliConfiguration(new CliRootCommand())
+            ParseResult result = new CommandLineConfiguration(new RootCommand())
                 .Parse(Constants.KnownHelpAliases[0]);
 
-            CliOption helpOption = result.CommandResult
+            Option helpOption = result.CommandResult
                 .Children
                 .OfType<OptionResult>()
                 .Select(r => r.Option)
@@ -151,7 +151,7 @@ public void ManuallyAddedOptionIsPreservedOnTemplateSubcommandLevel()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
 
-            var customOption = new CliOption<string>("--newOption")
+            var customOption = new Option<string>("--newOption")
             {
                 Recursive = true
             };
@@ -177,7 +177,7 @@ public void CanParseOutputOption(string command, string? expected)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
 
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Add(myCommand);
@@ -195,7 +195,7 @@ public void CanParseProjectOption(string command, string? expected)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
 
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
 
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Add(myCommand);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
index 51d647fee2df..cc75fe669e23 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
@@ -244,7 +244,7 @@ public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
@@ -258,7 +258,7 @@ public void CommandExampleShowsMandatoryArg()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
@@ -272,7 +272,7 @@ public void CommandExampleShowsOptionalArgWhenOptionsAreGiven()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
index 049cac00401c..94120f6f4b0f 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
@@ -13,7 +13,7 @@ public partial class TabCompletionTests : BaseTest
         public Task RootCommand_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = ParserFactory.CreateParser(myCommand).Parse("new ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -25,7 +25,7 @@ public Task RootCommand_GetAllSuggestions()
         public Task RootCommand_GetStartsWtihSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new c");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -37,7 +37,7 @@ public Task RootCommand_GetStartsWtihSuggestions()
         public Task Install_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new install ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -49,7 +49,7 @@ public Task Install_GetAllSuggestions()
         public Task Uninstall_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new uninstall ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -61,7 +61,7 @@ public Task Uninstall_GetAllSuggestions()
         public Task Update_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new update ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -73,7 +73,7 @@ public Task Update_GetAllSuggestions()
         public Task List_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new list ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -85,7 +85,7 @@ public Task List_GetAllSuggestions()
         public Task Search_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new search ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -97,7 +97,7 @@ public Task Search_GetAllSuggestions()
         public Task Create_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new create ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -109,7 +109,7 @@ public Task Create_GetAllSuggestions()
         public Task TemplateCommand_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new console ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -121,7 +121,7 @@ public Task TemplateCommand_GetAllSuggestions()
         public Task DetailsCommand_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new details ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
index a86538eab3b9..292a2839aae5 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
@@ -20,7 +20,7 @@ public partial class TabCompletionTests
         public void Instantiate_CanSuggestTemplateOption_StartsWith()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse($"new console --framework {ToolsetInfo.CurrentTargetFramework} --l");
             string[] suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -36,7 +36,7 @@ public void Instantiate_CanSuggestTemplateOption_StartsWith()
         public void Instantiate_CanSuggestLanguages()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new console --language ");
             string[] suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -53,7 +53,7 @@ public void Instantiate_CanSuggestLanguages()
         public void Install_GetSuggestionsAfterInteractive()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new install --interactive ");
             string[] result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -66,7 +66,7 @@ public void Install_GetSuggestionsAfterInteractive()
         public void Install_GetSuggestionsAfterOptionWithoutArg()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new install --nuget-source ");
             CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -80,7 +80,7 @@ public void Install_GetSuggestionsAfterOptionWithoutArg()
         public void Install_GetSuggestionsAfterOptionWithArg()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new install --nuget-source me");
             string[] result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -93,7 +93,7 @@ public void Install_GetSuggestionsAfterOptionWithArg()
         public void Instantiate_CanSuggestTemplate_StartsWith()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliCommand myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create("new", _ => host);
 
             ParseResult parseResult = myCommand.Parse("new co");
             string[] suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
index 481880e42f49..607f2dd2a7da 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
@@ -90,7 +90,7 @@ public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
index 7ada93f796ad..6fb3fe63d6ca 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
@@ -188,7 +188,7 @@ public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
-            CliCommand rootCommand = new("dotnet")
+            Command rootCommand = new("dotnet")
             {
                 myCommand
             };
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
index 6df8a4eb41ae..b9dee47fad62 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
@@ -596,7 +596,7 @@ public async Task TestGetTemplateResolutionResult_IgnoreConstraintsMismatch()
         private static ListCommandArgs GetListCommandArgsFor(string commandInput)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            CliRootCommand rootCommand = new();
+            RootCommand rootCommand = new();
             NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
             rootCommand.Add(myCommand);
 
diff --git a/test/dotnet-build.Tests/GivenDotnetBuildBuildsCsproj.cs b/test/dotnet-build.Tests/GivenDotnetBuildBuildsCsproj.cs
index ea4268d5245d..5bff8953558d 100644
--- a/test/dotnet-build.Tests/GivenDotnetBuildBuildsCsproj.cs
+++ b/test/dotnet-build.Tests/GivenDotnetBuildBuildsCsproj.cs
@@ -400,8 +400,8 @@ static string RelativeNuGetPath(string absoluteNuGetPath)
         [InlineData("run")]
         public void It_uses_correct_runtime_help_description(string command)
         {
-            CliConfiguration sharedConfig = Parser.Instance;
-            CliConfiguration localCopy = new(sharedConfig.RootCommand)
+            CommandLineConfiguration sharedConfig = Parser.Instance;
+            CommandLineConfiguration localCopy = new(sharedConfig.RootCommand)
             {
                 EnableDefaultExceptionHandler = sharedConfig.EnableDefaultExceptionHandler,
                 ResponseFileTokenReplacer = sharedConfig.ResponseFileTokenReplacer,
diff --git a/test/dotnet.Tests/ParserTests/BuildRelatedCommandParserTests.cs b/test/dotnet.Tests/ParserTests/BuildRelatedCommandParserTests.cs
index b3a4042afaac..f99403526d04 100644
--- a/test/dotnet.Tests/ParserTests/BuildRelatedCommandParserTests.cs
+++ b/test/dotnet.Tests/ParserTests/BuildRelatedCommandParserTests.cs
@@ -47,12 +47,12 @@ public static TheoryData<string, string> BuildRelatedCommandsAndOptions()
         [Theory]
         public void Build(string command, string option)
         {
-            var cliCommand = Parser.Instance.RootCommand.Children.OfType<CliCommand>().FirstOrDefault(c => c.Name == command);
+            var cliCommand = Parser.Instance.RootCommand.Children.OfType<Command>().FirstOrDefault(c => c.Name == command);
             if (cliCommand is null)
             {
                 throw new ArgumentException($"Command {command} not found in the dotnet CLI");
             }
-            var cliOption = cliCommand.Children.OfType<CliOption>().FirstOrDefault(o => o.Name == option || o.Aliases.Contains(option));
+            var cliOption = cliCommand.Children.OfType<Option>().FirstOrDefault(o => o.Name == option || o.Aliases.Contains(option));
             if (cliOption is null)
             {
                 throw new ArgumentException($"Option {option} not found in the {command} command");
diff --git a/test/dotnet.Tests/ParserTests/MSBuildArgumentCommandLineParserTests.cs b/test/dotnet.Tests/ParserTests/MSBuildArgumentCommandLineParserTests.cs
index 3ef89b177a9e..1f41d7a2ebb9 100644
--- a/test/dotnet.Tests/ParserTests/MSBuildArgumentCommandLineParserTests.cs
+++ b/test/dotnet.Tests/ParserTests/MSBuildArgumentCommandLineParserTests.cs
@@ -54,7 +54,7 @@ public void MSBuildArgumentsAreForwardedCorrectly(string[] arguments, bool build
         public void Can_pass_msbuild_properties_safely(string[] tokens, string[] forwardedTokens)
         {
             var forwardingFunction = (CommonOptions.PropertiesOption as ForwardedOption<string[]>).GetForwardingFunction();
-            var result = new CliRootCommand() { CommonOptions.PropertiesOption }.Parse(tokens);
+            var result = new RootCommand() { CommonOptions.PropertiesOption }.Parse(tokens);
             var parsedTokens = forwardingFunction(result);
             parsedTokens.Should().BeEquivalentTo(forwardedTokens);
         }

From f9abd3750c38e03fccab1b7f9f2333f666dbe601 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]" <dotnet-maestro[bot]@users.noreply.github.com>
Date: Sat, 1 Feb 2025 05:01:26 +0000
Subject: [PATCH 3/4] Update dependencies from
 https://github.com/dotnet/sourcelink build 20250131.2

Microsoft.SourceBuild.Intermediate.sourcelink , Microsoft.Build.Tasks.Git , Microsoft.SourceLink.AzureRepos.Git , Microsoft.SourceLink.Bitbucket.Git , Microsoft.SourceLink.Common , Microsoft.SourceLink.GitHub , Microsoft.SourceLink.GitLab
 From Version 10.0.0-beta.25080.2 -> To Version 10.0.0-beta.25081.2
---
 eng/Version.Details.xml | 28 ++++++++++++++--------------
 eng/Versions.props      | 12 ++++++------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ec792afc42d5..9f7b18fc94da 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -475,34 +475,34 @@
       <Uri>https://github.com/dotnet/deployment-tools</Uri>
       <Sha>eddd72e696074a457cabf62df5d889928324e0b7</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.Build.Tasks.Git" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.Build.Tasks.Git" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.SourceLink.Common" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.SourceLink.Common" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.SourceLink.AzureRepos.Git" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.SourceLink.AzureRepos.Git" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.SourceLink.GitHub" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.SourceLink.GitHub" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.SourceLink.GitLab" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.SourceLink.GitLab" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.SourceLink.Bitbucket.Git" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.SourceLink.Bitbucket.Git" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.sourcelink" Version="10.0.0-beta.25080.2">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.sourcelink" Version="10.0.0-beta.25081.2">
       <Uri>https://github.com/dotnet/sourcelink</Uri>
-      <Sha>fab841741055c19fc07623f8947cecc9a0f63baa</Sha>
+      <Sha>3c34adccbef5b95e680bc6e6424e3ebbbf4cd294</Sha>
       <SourceBuild RepoName="sourcelink" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
diff --git a/eng/Versions.props b/eng/Versions.props
index 291903b685f2..84477ccf2c56 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -277,12 +277,12 @@
   </PropertyGroup>
   <PropertyGroup>
     <!-- Dependencies from https://github.com/dotnet/sourcelink -->
-    <MicrosoftBuildTasksGitVersion>10.0.0-beta.25080.2</MicrosoftBuildTasksGitVersion>
-    <MicrosoftSourceLinkCommonVersion>10.0.0-beta.25080.2</MicrosoftSourceLinkCommonVersion>
-    <MicrosoftSourceLinkAzureReposGitVersion>10.0.0-beta.25080.2</MicrosoftSourceLinkAzureReposGitVersion>
-    <MicrosoftSourceLinkGitHubVersion>10.0.0-beta.25080.2</MicrosoftSourceLinkGitHubVersion>
-    <MicrosoftSourceLinkGitLabVersion>10.0.0-beta.25080.2</MicrosoftSourceLinkGitLabVersion>
-    <MicrosoftSourceLinkBitbucketGitVersion>10.0.0-beta.25080.2</MicrosoftSourceLinkBitbucketGitVersion>
+    <MicrosoftBuildTasksGitVersion>10.0.0-beta.25081.2</MicrosoftBuildTasksGitVersion>
+    <MicrosoftSourceLinkCommonVersion>10.0.0-beta.25081.2</MicrosoftSourceLinkCommonVersion>
+    <MicrosoftSourceLinkAzureReposGitVersion>10.0.0-beta.25081.2</MicrosoftSourceLinkAzureReposGitVersion>
+    <MicrosoftSourceLinkGitHubVersion>10.0.0-beta.25081.2</MicrosoftSourceLinkGitHubVersion>
+    <MicrosoftSourceLinkGitLabVersion>10.0.0-beta.25081.2</MicrosoftSourceLinkGitLabVersion>
+    <MicrosoftSourceLinkBitbucketGitVersion>10.0.0-beta.25081.2</MicrosoftSourceLinkBitbucketGitVersion>
   </PropertyGroup>
   <!-- Get .NET Framework reference assemblies from NuGet packages -->
   <PropertyGroup>

From 9ada413c1046284ed16d1971d957e41db724c2ab Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]" <dotnet-maestro[bot]@users.noreply.github.com>
Date: Mon, 3 Feb 2025 22:46:07 +0000
Subject: [PATCH 4/4] Update dependencies from https://github.com/dotnet/arcade
 build 20250203.6

Microsoft.SourceBuild.Intermediate.arcade , Microsoft.DotNet.Arcade.Sdk , Microsoft.DotNet.Build.Tasks.Installers , Microsoft.DotNet.Helix.Sdk , Microsoft.DotNet.SignTool , Microsoft.DotNet.XliffTasks , Microsoft.DotNet.XUnitExtensions
 From Version 10.0.0-beta.25080.7 -> To Version 10.0.0-beta.25103.6
---
 eng/Version.Details.xml | 28 ++++++++++++++--------------
 eng/Versions.props      |  8 ++++----
 global.json             |  4 ++--
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 9f7b18fc94da..ef528e27fc14 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -604,34 +604,34 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.DotNet.Build.Tasks.Installers" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.SignTool" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.DotNet.SignTool" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XliffTasks" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.DotNet.XliffTasks" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.arcade" Version="10.0.0-beta.25080.7">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.arcade" Version="10.0.0-beta.25103.6">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>bbea86c614fcf4380c58c80eacd279a0b8305a79</Sha>
+      <Sha>0b971a5e11be58af22ca83fbc111a1207bb62920</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="System.Reflection.MetadataLoadContext" Version="10.0.0-preview.2.25101.4">
diff --git a/eng/Versions.props b/eng/Versions.props
index 84477ccf2c56..340ed5b97b76 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -270,10 +270,10 @@
   </PropertyGroup>
   <PropertyGroup>
     <!-- Dependencies from https://github.com/dotnet/arcade -->
-    <MicrosoftDotNetBuildTasksInstallersPackageVersion>10.0.0-beta.25080.7</MicrosoftDotNetBuildTasksInstallersPackageVersion>
-    <MicrosoftDotNetSignToolVersion>10.0.0-beta.25080.7</MicrosoftDotNetSignToolVersion>
-    <MicrosoftDotNetXliffTasksVersion>10.0.0-beta.25080.7</MicrosoftDotNetXliffTasksVersion>
-    <MicrosoftDotNetXUnitExtensionsVersion>10.0.0-beta.25080.7</MicrosoftDotNetXUnitExtensionsVersion>
+    <MicrosoftDotNetBuildTasksInstallersPackageVersion>10.0.0-beta.25103.6</MicrosoftDotNetBuildTasksInstallersPackageVersion>
+    <MicrosoftDotNetSignToolVersion>10.0.0-beta.25103.6</MicrosoftDotNetSignToolVersion>
+    <MicrosoftDotNetXliffTasksVersion>10.0.0-beta.25103.6</MicrosoftDotNetXliffTasksVersion>
+    <MicrosoftDotNetXUnitExtensionsVersion>10.0.0-beta.25103.6</MicrosoftDotNetXUnitExtensionsVersion>
   </PropertyGroup>
   <PropertyGroup>
     <!-- Dependencies from https://github.com/dotnet/sourcelink -->
diff --git a/global.json b/global.json
index 069338eb4678..716aac7bc79a 100644
--- a/global.json
+++ b/global.json
@@ -17,8 +17,8 @@
     "cmake": "latest"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "10.0.0-beta.25080.7",
-    "Microsoft.DotNet.Helix.Sdk": "10.0.0-beta.25080.7",
+    "Microsoft.DotNet.Arcade.Sdk": "10.0.0-beta.25103.6",
+    "Microsoft.DotNet.Helix.Sdk": "10.0.0-beta.25103.6",
     "Microsoft.Build.NoTargets": "3.7.0",
     "Microsoft.DotNet.CMake.Sdk": "9.0.0-beta.24217.1"
   }