diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
index 60639de334..25256b757a 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
@@ -19,67 +19,25 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal abstract class BaseCommand : Command
     {
-        private readonly ITemplateEngineHost _host;
+        private readonly Func<ParseResult, ITemplateEngineHost> _hostBuilder;
+        private readonly Func<ParseResult, ITelemetryLogger> _telemetryLoggerBuilder;
 
         protected BaseCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string name,
             string description)
             : base(name, description)
         {
-            _host = host;
-            TelemetryLogger = logger;
+            _hostBuilder = hostBuilder;
+            _telemetryLoggerBuilder = telemetryLoggerBuilder;
             Callbacks = callbacks;
-            this.AddOption(DebugCustomSettingsLocationOption);
-            this.AddOption(DebugVirtualizeSettingsOption);
-            this.AddOption(DebugAttachOption);
-            this.AddOption(DebugReinitOption);
-            this.AddOption(DebugRebuildCacheOption);
-            this.AddOption(DebugShowConfigOption);
+
         }
 
         protected BaseCommand(BaseCommand baseCommand, string name, string description)
-             : this(baseCommand._host, baseCommand.TelemetryLogger, baseCommand.Callbacks, name, description) { }
-
-        internal Option<string?> DebugCustomSettingsLocationOption { get; } = new("--debug:custom-hive")
-        {
-            Description = SymbolStrings.Option_Debug_CustomSettings,
-            IsHidden = true
-        };
-
-        internal Option<bool> DebugVirtualizeSettingsOption { get; } = new("--debug:ephemeral-hive")
-        {
-            Description = SymbolStrings.Option_Debug_VirtualSettings,
-            IsHidden = true
-        };
-
-        internal Option<bool> DebugAttachOption { get; } = new("--debug:attach")
-        {
-            Description = SymbolStrings.Option_Debug_Attach,
-            IsHidden = true
-        };
-
-        internal Option<bool> DebugReinitOption { get; } = new("--debug:reinit")
-        {
-            Description = SymbolStrings.Option_Debug_Reinit,
-            IsHidden = true
-        };
-
-        internal Option<bool> DebugRebuildCacheOption { get; } = new(new[] { "--debug:rebuild-cache", "--debug:rebuildcache" })
-        {
-            Description = SymbolStrings.Option_Debug_RebuildCache,
-            IsHidden = true
-        };
-
-        internal Option<bool> DebugShowConfigOption { get; } = new(new[] { "--debug:show-config", "--debug:showconfig" })
-        {
-            Description = SymbolStrings.Option_Debug_ShowConfig,
-            IsHidden = true
-        };
-
-        internal ITelemetryLogger TelemetryLogger { get; }
+             : this(baseCommand._hostBuilder, baseCommand._telemetryLoggerBuilder, baseCommand.Callbacks, name, description) { }
 
         internal NewCommandCallbacks Callbacks { get; }
 
@@ -90,13 +48,18 @@ protected IEngineEnvironmentSettings CreateEnvironmentSettings(GlobalArgs args,
             //for template instantiaton it has to be reparsed
             string? outputPath = ParseOutputOption(parseResult);
             IEngineEnvironmentSettings environmentSettings = new EngineEnvironmentSettings(
-                new CliTemplateEngineHost(_host, outputPath),
+                new CliTemplateEngineHost(_hostBuilder(parseResult), outputPath),
                 settingsLocation: args.DebugCustomSettingsLocation,
                 virtualizeSettings: args.DebugVirtualizeSettings,
                 environment: new CliEnvironment());
             return environmentSettings;
         }
 
+        protected ITelemetryLogger CreateTelemetryLogger(ParseResult parseResult)
+        {
+            return _telemetryLoggerBuilder(parseResult);
+        }
+
         private static string? ParseOutputOption(ParseResult commandParseResult)
         {
             Option<string> outputOption = SharedOptionsFactory.CreateOutputOption();
@@ -117,12 +80,12 @@ protected IEngineEnvironmentSettings CreateEnvironmentSettings(GlobalArgs args,
     internal abstract class BaseCommand<TArgs> : BaseCommand, ICommandHandler where TArgs : GlobalArgs
     {
         internal BaseCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string name,
             string description)
-            : base(host, logger, callbacks, name, description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, name, description)
         {
             this.Handler = this;
         }
@@ -135,6 +98,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
         {
             TArgs args = ParseContext(context.ParseResult);
             IEngineEnvironmentSettings environmentSettings = CreateEnvironmentSettings(args, context.ParseResult);
+            ITelemetryLogger telemetryLogger = CreateTelemetryLogger(context.ParseResult);
 
             CancellationToken cancellationToken = context.GetCancellationToken();
 
@@ -143,7 +107,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
                 using (Timing.Over(environmentSettings.Host.Logger, "Execute"))
                 {
                     await HandleGlobalOptionsAsync(args, environmentSettings, cancellationToken).ConfigureAwait(false);
-                    return (int)await ExecuteAsync(args, environmentSettings, context).ConfigureAwait(false);
+                    return (int)await ExecuteAsync(args, environmentSettings, telemetryLogger, context).ConfigureAwait(false);
                 }
             }
             catch (Exception ex)
@@ -193,7 +157,7 @@ protected internal virtual IEnumerable<CompletionItem> GetCompletions(Completion
             return base.GetCompletions(context);
         }
 
-        protected abstract Task<NewCommandStatus> ExecuteAsync(TArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context);
+        protected abstract Task<NewCommandStatus> ExecuteAsync(TArgs args, IEngineEnvironmentSettings environmentSettings, ITelemetryLogger telemetryLogger, InvocationContext context);
 
         protected abstract TArgs ParseContext(ParseResult parseResult);
 
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs b/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
index 18662d1417..436873c6eb 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
@@ -11,12 +11,12 @@ internal class GlobalArgs
     {
         public GlobalArgs(BaseCommand command, ParseResult parseResult)
         {
-            DebugCustomSettingsLocation = parseResult.GetValueForOption(command.DebugCustomSettingsLocationOption);
-            DebugVirtualizeSettings = parseResult.GetValueForOption(command.DebugVirtualizeSettingsOption);
-            DebugAttach = parseResult.GetValueForOption(command.DebugAttachOption);
-            DebugReinit = parseResult.GetValueForOption(command.DebugReinitOption);
-            DebugRebuildCache = parseResult.GetValueForOption(command.DebugRebuildCacheOption);
-            DebugShowConfig = parseResult.GetValueForOption(command.DebugShowConfigOption);
+            DebugCustomSettingsLocation = parseResult.GetValueForOption(NewCommand.DebugCustomSettingsLocationOption);
+            DebugVirtualizeSettings = parseResult.GetValueForOption(NewCommand.DebugVirtualizeSettingsOption);
+            DebugAttach = parseResult.GetValueForOption(NewCommand.DebugAttachOption);
+            DebugReinit = parseResult.GetValueForOption(NewCommand.DebugReinitOption);
+            DebugRebuildCache = parseResult.GetValueForOption(NewCommand.DebugRebuildCacheOption);
+            DebugShowConfig = parseResult.GetValueForOption(NewCommand.DebugShowConfigOption);
             CommandName = parseResult.GetNewCommandName();
             ParseResult = parseResult;
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs b/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
index 3eff50ef1f..722994f010 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
@@ -35,6 +35,21 @@ internal partial class NewCommand : BaseCommand<NewCommandArgs>
             IsHidden = true
         };
 
+        internal IEnumerable<Option> LegacyOptions
+        {
+            get
+            {
+                yield return InteractiveOption;
+                yield return AddSourceOption;
+                yield return ColumnsAllOption;
+                yield return ColumnsOption;
+                foreach (Option filter in LegacyFilters.Values)
+                {
+                    yield return filter;
+                }
+            }
+        }
+
         internal Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption().AsHidden();
 
         internal Option<IReadOnlyList<string>> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
@@ -126,7 +141,7 @@ internal void AddNoLegacyUsageValidators(Command command, params Symbol[] except
             return null;
         }
 
-        private void BuildLegacySymbols(ITemplateEngineHost host, ITelemetryLogger telemetryLogger, NewCommandCallbacks callbacks)
+        private void BuildLegacySymbols(Func<ParseResult, ITemplateEngineHost> hostBuilder, Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder, NewCommandCallbacks callbacks)
         {
             this.AddArgument(ShortNameArgument);
             this.AddArgument(RemainingArguments);
@@ -147,14 +162,14 @@ private void BuildLegacySymbols(ITemplateEngineHost host, ITelemetryLogger telem
 
             this.TreatUnmatchedTokensAsErrors = true;
 
-            this.Add(new LegacyInstallCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new LegacyUninstallCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new LegacyUpdateCheckCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new LegacyUpdateApplyCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new LegacySearchCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new LegacyListCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new LegacyAliasAddCommand(host, telemetryLogger, callbacks));
-            this.Add(new LegacyAliasShowCommand(host, telemetryLogger, callbacks));
+            this.Add(new LegacyInstallCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacyUninstallCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacyUpdateCheckCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacyUpdateApplyCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacySearchCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacyListCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacyAliasAddCommand(hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new LegacyAliasShowCommand(hostBuilder, telemetryLoggerBuilder, callbacks));
         }
     }
 }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
index c5ba1d6245..75ba1336cb 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.CommandLine;
 using System.CommandLine.Completions;
 using System.CommandLine.Invocation;
 using System.CommandLine.Parsing;
@@ -14,25 +15,68 @@ internal partial class NewCommand : BaseCommand<NewCommandArgs>, ICustomHelp
     {
         internal NewCommand(
             string commandName,
-            ITemplateEngineHost host,
-            ITelemetryLogger telemetryLogger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(host, telemetryLogger, callbacks, commandName, SymbolStrings.Command_New_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_New_Description)
         {
             this.TreatUnmatchedTokensAsErrors = true;
 
             //it is important that legacy commands are built before non-legacy, as non legacy commands are building validators that rely on legacy stuff
-            BuildLegacySymbols(host, telemetryLogger, callbacks);
-
-            this.Add(new InstantiateCommand(host, telemetryLogger, callbacks));
-            this.Add(new InstallCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new UninstallCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new UpdateCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new SearchCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new ListCommand(this, host, telemetryLogger, callbacks));
-            this.Add(new AliasCommand(host, telemetryLogger, callbacks));
+            BuildLegacySymbols(hostBuilder, telemetryLoggerBuilder, callbacks);
+
+            this.Add(new InstantiateCommand(hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new InstallCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new UninstallCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new UpdateCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new SearchCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new ListCommand(this, hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new AliasCommand(hostBuilder, telemetryLoggerBuilder, callbacks));
+
+            this.AddGlobalOption(DebugCustomSettingsLocationOption);
+            this.AddGlobalOption(DebugVirtualizeSettingsOption);
+            this.AddGlobalOption(DebugAttachOption);
+            this.AddGlobalOption(DebugReinitOption);
+            this.AddGlobalOption(DebugRebuildCacheOption);
+            this.AddGlobalOption(DebugShowConfigOption);
         }
 
+        internal static Option<string?> DebugCustomSettingsLocationOption { get; } = new("--debug:custom-hive")
+        {
+            Description = SymbolStrings.Option_Debug_CustomSettings,
+            IsHidden = true
+        };
+
+        internal static Option<bool> DebugVirtualizeSettingsOption { get; } = new(new[] { "--debug:ephemeral-hive", "--debug:virtual-hive" })
+        {
+            Description = SymbolStrings.Option_Debug_VirtualSettings,
+            IsHidden = true
+        };
+
+        internal static Option<bool> DebugAttachOption { get; } = new("--debug:attach")
+        {
+            Description = SymbolStrings.Option_Debug_Attach,
+            IsHidden = true
+        };
+
+        internal static Option<bool> DebugReinitOption { get; } = new("--debug:reinit")
+        {
+            Description = SymbolStrings.Option_Debug_Reinit,
+            IsHidden = true
+        };
+
+        internal static Option<bool> DebugRebuildCacheOption { get; } = new(new[] { "--debug:rebuild-cache", "--debug:rebuildcache" })
+        {
+            Description = SymbolStrings.Option_Debug_RebuildCache,
+            IsHidden = true
+        };
+
+        internal static Option<bool> DebugShowConfigOption { get; } = new(new[] { "--debug:show-config", "--debug:showconfig" })
+        {
+            Description = SymbolStrings.Option_Debug_ShowConfig,
+            IsHidden = true
+        };
+
         protected internal override IEnumerable<CompletionItem> GetCompletions(CompletionContext context, IEngineEnvironmentSettings environmentSettings)
         {
             if (context is not TextCompletionContext textCompletionContext)
@@ -53,11 +97,15 @@ protected internal override IEnumerable<CompletionItem> GetCompletions(Completio
 
         }
 
-        protected override Task<NewCommandStatus> ExecuteAsync(NewCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected override Task<NewCommandStatus> ExecuteAsync(
+            NewCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             InstantiateCommand command = InstantiateCommand.FromNewCommand(this);
             ParseResult reparseResult = ParserFactory.CreateParser(command).Parse(args.Tokens);
-            return command.ExecuteAsync(reparseResult, environmentSettings, context);
+            return command.ExecuteAsync(reparseResult, environmentSettings, telemetryLogger, context);
         }
 
         protected override NewCommandArgs ParseContext(ParseResult parseResult) => new(this, parseResult);
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs
index 8318768314..de3c1f4011 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs
@@ -3,13 +3,18 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class AliasAddCommand : BaseAliasAddCommand
     {
-        internal AliasAddCommand(ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks) : base(host, logger, callbacks, "add")
+        internal AliasAddCommand(
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
+            NewCommandCallbacks callbacks)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "add")
         {
             IsHidden = true;
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs
index cec61a2e4e..febc133057 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs
@@ -12,17 +12,21 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     internal class AliasCommand : BaseCommand<AliasCommandArgs>
     {
         internal AliasCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger telemetryLogger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(host, telemetryLogger, callbacks, "alias", SymbolStrings.Command_Alias_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "alias", SymbolStrings.Command_Alias_Description)
         {
             IsHidden = true;
-            this.Add(new AliasAddCommand(host, telemetryLogger, callbacks));
-            this.Add(new AliasShowCommand(host, telemetryLogger, callbacks));
+            this.Add(new AliasAddCommand(hostBuilder, telemetryLoggerBuilder, callbacks));
+            this.Add(new AliasShowCommand(hostBuilder, telemetryLoggerBuilder, callbacks));
         }
 
-        protected override Task<NewCommandStatus> ExecuteAsync(AliasCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context) => throw new NotImplementedException();
+        protected override Task<NewCommandStatus> ExecuteAsync(
+            AliasCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context) => throw new NotImplementedException();
 
         protected override AliasCommandArgs ParseContext(ParseResult parseResult) => new(this, parseResult);
     }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs
index 741192883f..a2e0b8bf82 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs
@@ -3,13 +3,18 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class AliasShowCommand : BaseAliasShowCommand
     {
-        internal AliasShowCommand(ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks) : base(host, logger, callbacks, "show")
+        internal AliasShowCommand(
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
+            NewCommandCallbacks callbacks)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "show")
         {
             IsHidden = true;
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs
index ed8922e25d..d2d605aff8 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs
@@ -12,13 +12,17 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     internal class BaseAliasAddCommand : BaseCommand<AliasAddCommandArgs>
     {
         internal BaseAliasAddCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName)
-            : base(host, logger, callbacks, commandName, SymbolStrings.Command_AliasAdd_Description) { }
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_AliasAdd_Description) { }
 
-        protected override Task<NewCommandStatus> ExecuteAsync(AliasAddCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context) => throw new NotImplementedException();
+        protected override Task<NewCommandStatus> ExecuteAsync(
+            AliasAddCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context) => throw new NotImplementedException();
 
         protected override AliasAddCommandArgs ParseContext(ParseResult parseResult) => new(this, parseResult);
     }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs
index 26429f1795..bd01dae054 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs
@@ -12,13 +12,17 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     internal class BaseAliasShowCommand : BaseCommand<AliasShowCommandArgs>
     {
         internal BaseAliasShowCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName)
-            : base(host, logger, callbacks, commandName, SymbolStrings.Command_AliasShow_Description) { }
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_AliasShow_Description) { }
 
-        protected override Task<NewCommandStatus> ExecuteAsync(AliasShowCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context) => throw new NotImplementedException();
+        protected override Task<NewCommandStatus> ExecuteAsync(
+            AliasShowCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context) => throw new NotImplementedException();
 
         protected override AliasShowCommandArgs ParseContext(ParseResult parseResult) => new(this, parseResult);
     }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs
index 0343de8996..e4d2cf3d47 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs
@@ -3,13 +3,18 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class LegacyAliasAddCommand : BaseAliasAddCommand
     {
-        internal LegacyAliasAddCommand(ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks) : base(host, logger, callbacks, "--alias")
+        internal LegacyAliasAddCommand(
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
+            NewCommandCallbacks callbacks)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "--alias")
         {
             AddAlias("-a");
             IsHidden = true;
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs
index 59d277803e..2147664636 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs
@@ -3,13 +3,18 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class LegacyAliasShowCommand : BaseAliasShowCommand
     {
-        internal LegacyAliasShowCommand(ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks) : base(host, logger, callbacks, "--show-alias")
+        internal LegacyAliasShowCommand(
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
+            NewCommandCallbacks callbacks)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "--show-alias")
         {
             IsHidden = true;
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
index 20cc52dcf7..0bc6dc7a62 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
@@ -22,10 +22,10 @@ internal partial class InstantiateCommand : BaseCommand<InstantiateCommandArgs>,
         private NewCommand? _parentCommand;
 
         internal InstantiateCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(host, logger, callbacks, "create", SymbolStrings.Command_Instantiate_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "create", SymbolStrings.Command_Instantiate_Description)
         {
             this.AddArgument(ShortNameArgument);
             this.AddArgument(RemainingArguments);
@@ -63,12 +63,19 @@ internal static InstantiateCommand FromNewCommand(NewCommand parentCommand)
             {
                 command.Add(subcommand);
             }
+
+            //do not re-add legacy options - they are not needed
+            //do not hardcode option as the caller of CLI (SDK) can add extra options that should be moved
+            foreach (var option in parentCommand.Children.OfType<Option>().Where(o => !parentCommand.LegacyOptions.Contains(o)))
+            {
+                command.Add(option);
+            }
             return command;
         }
 
-        internal Task<NewCommandStatus> ExecuteAsync(ParseResult parseResult, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        internal Task<NewCommandStatus> ExecuteAsync(ParseResult parseResult, IEngineEnvironmentSettings environmentSettings, ITelemetryLogger telemetryLogger, InvocationContext context)
         {
-            return ExecuteAsync(ParseContext(parseResult), environmentSettings, context);
+            return ExecuteAsync(ParseContext(parseResult), environmentSettings, telemetryLogger, context);
         }
 
         internal HashSet<TemplateCommand> GetTemplateCommand(
@@ -183,7 +190,11 @@ async Task<string> GetTemplatePackagesList(TemplateGroup templateGroup)
             }
         }
 
-        protected async override Task<NewCommandStatus> ExecuteAsync(InstantiateCommandArgs instantiateArgs, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected async override Task<NewCommandStatus> ExecuteAsync(
+            InstantiateCommandArgs instantiateArgs,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             var cancellationToken = context.GetCancellationToken();
             using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
@@ -194,7 +205,7 @@ protected async override Task<NewCommandStatus> ExecuteAsync(InstantiateCommandA
                     environmentSettings,
                     templatePackageManager,
                     hostSpecificDataLoader,
-                    TelemetryLogger);
+                    telemetryLogger);
 
                 return await templateListCoordinator.DisplayCommandDescriptionAsync(instantiateArgs, cancellationToken).ConfigureAwait(false);
             }
@@ -217,6 +228,7 @@ protected async override Task<NewCommandStatus> ExecuteAsync(InstantiateCommandA
             return await HandleTemplateInstantationAsync(
                 instantiateArgs,
                 environmentSettings,
+                telemetryLogger,
                 templatePackageManager,
                 selectedTemplateGroups.Single(),
                 cancellationToken).ConfigureAwait(false);
@@ -259,6 +271,7 @@ private static NewCommandStatus HandleAmbiguousType(
         private async Task<NewCommandStatus> HandleTemplateInstantationAsync(
             InstantiateCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
             TemplatePackageManager templatePackageManager,
             TemplateGroup templateGroup,
             CancellationToken cancellationToken)
@@ -267,7 +280,9 @@ private async Task<NewCommandStatus> HandleTemplateInstantationAsync(
             if (candidates.Count == 1)
             {
                 Command commandToRun = _parentCommand is null ? this : _parentCommand;
-                commandToRun.AddCommand(candidates.First());
+                TemplateCommand templateCommandToRun = candidates.Single();
+                templateCommandToRun.SetHandler((InvocationContext context) => templateCommandToRun.InvokeAsync(context, telemetryLogger));
+                commandToRun.AddCommand(templateCommandToRun);
                 return (NewCommandStatus)await commandToRun.InvokeAsync(args.TokensToInvoke).ConfigureAwait(false);
             }
             else if (candidates.Any())
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
index 037ebbb243..b1677624eb 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class TemplateCommand : Command, ICommandHandler
+    internal class TemplateCommand : Command
     {
         private static readonly string[] _helpAliases = new[] { "-h", "/h", "--help", "-?", "/?" };
         private readonly TemplatePackageManager _templatePackageManager;
@@ -111,7 +111,6 @@ public TemplateCommand(
             }
 
             AddTemplateOptionsToCommand(template);
-            this.Handler = this;
         }
 
         internal static IReadOnlyList<string> KnownHelpAliases => _helpAliases;
@@ -154,14 +153,14 @@ public TemplateCommand(
 
         internal CliTemplateInfo Template => _template;
 
-        public async Task<int> InvokeAsync(InvocationContext context)
+        public async Task<int> InvokeAsync(InvocationContext context, ITelemetryLogger telemetryLogger)
         {
             TemplateCommandArgs args = new TemplateCommandArgs(this, context.ParseResult);
 
-            TemplateInvoker invoker = new TemplateInvoker(_environmentSettings, _instantiateCommand.TelemetryLogger, () => Console.ReadLine() ?? string.Empty, _instantiateCommand.Callbacks);
+            TemplateInvoker invoker = new TemplateInvoker(_environmentSettings, telemetryLogger, () => Console.ReadLine() ?? string.Empty, _instantiateCommand.Callbacks);
             if (!args.NoUpdateCheck)
             {
-                TemplatePackageCoordinator packageCoordinator = new TemplatePackageCoordinator(_instantiateCommand.TelemetryLogger, _environmentSettings, _templatePackageManager);
+                TemplatePackageCoordinator packageCoordinator = new TemplatePackageCoordinator(telemetryLogger, _environmentSettings, _templatePackageManager);
                 Task<CheckUpdateResult?> checkForUpdateTask = packageCoordinator.CheckUpdateForTemplate(args.Template, context.GetCancellationToken());
                 Task<NewCommandStatus> instantiateTask = invoker.InvokeTemplateAsync(args, context.GetCancellationToken());
                 await Task.WhenAll(checkForUpdateTask, instantiateTask).ConfigureAwait(false);
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
index 0dac4b736c..49328bb0c7 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
@@ -15,11 +15,11 @@ internal abstract class BaseInstallCommand : BaseCommand<InstallCommandArgs>
     {
         internal BaseInstallCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName)
-            : base(host, logger, callbacks, commandName, SymbolStrings.Command_Install_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_Install_Description)
         {
             ParentCommand = parentCommand;
             this.AddArgument(NameArgument);
@@ -39,11 +39,15 @@ internal BaseInstallCommand(
 
         protected NewCommand ParentCommand { get; }
 
-        protected override async Task<NewCommandStatus> ExecuteAsync(InstallCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected override async Task<NewCommandStatus> ExecuteAsync(
+            InstallCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
             TemplatePackageCoordinator templatePackageCoordinator = new TemplatePackageCoordinator(
-                TelemetryLogger,
+                telemetryLogger,
                 environmentSettings,
                 templatePackageManager);
 
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs
index dd2dfa42a4..14da2fa1bc 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs
@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -11,10 +12,10 @@ internal class InstallCommand : BaseInstallCommand
     {
         public InstallCommand(
                 NewCommand parentCommand,
-                ITemplateEngineHost host,
-                ITelemetryLogger logger,
+                Func<ParseResult, ITemplateEngineHost> hostBuilder,
+                Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
                 NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "install")
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "install")
         {
             parentCommand.AddNoLegacyUsageValidators(this);
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
index c64a624d02..e90ba45621 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
@@ -4,14 +4,15 @@
 #nullable enable
 
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class LegacyInstallCommand : BaseInstallCommand
     {
-        public LegacyInstallCommand(NewCommand parentCommand, ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "--install")
+        public LegacyInstallCommand(NewCommand parentCommand, Func<ParseResult, ITemplateEngineHost> hostBuilder, Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder, NewCommandCallbacks callbacks)
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "--install")
         {
             this.IsHidden = true;
             this.AddAlias("-i");
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
index 0c3b6e5e3f..fa8846fe3a 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
@@ -24,11 +24,11 @@ internal class BaseListCommand : BaseCommand<ListCommandArgs>, IFilterableComman
 
         internal BaseListCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName)
-            : base(host, logger, callbacks, commandName, SymbolStrings.Command_List_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_List_Description)
         {
             ParentCommand = parentCommand;
             Filters = SetupFilterOptions(SupportedFilters);
@@ -51,14 +51,18 @@ internal BaseListCommand(
 
         internal NewCommand ParentCommand { get; }
 
-        protected override async Task<NewCommandStatus> ExecuteAsync(ListCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected override async Task<NewCommandStatus> ExecuteAsync(
+            ListCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
             TemplateListCoordinator templateListCoordinator = new TemplateListCoordinator(
                 environmentSettings,
                 templatePackageManager,
                 new HostSpecificDataLoader(environmentSettings),
-                TelemetryLogger);
+                telemetryLogger);
 
             //we need to await, otherwise templatePackageManager will be disposed.
             return await templateListCoordinator.DisplayTemplateGroupListAsync(args, default).ConfigureAwait(false);
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
index dc5c236790..79647c12ae 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
@@ -11,8 +11,12 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class LegacyListCommand : BaseListCommand
     {
-        public LegacyListCommand(NewCommand parentCommand, ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "--list")
+        public LegacyListCommand(
+            NewCommand parentCommand,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
+            NewCommandCallbacks callbacks)
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "--list")
         {
             this.IsHidden = true;
             this.AddAlias("-l");
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs
index e51ddeec7d..4995b707c8 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs
@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -11,10 +12,10 @@ internal class ListCommand : BaseListCommand
     {
         public ListCommand(
                 NewCommand parentCommand,
-                ITemplateEngineHost host,
-                ITelemetryLogger logger,
+                Func<ParseResult, ITemplateEngineHost> hostBuilder,
+                Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
                 NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "list")
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "list")
         {
             parentCommand.AddNoLegacyUsageValidators(this);
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
index 13502e83c4..8a544414f6 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
@@ -27,11 +27,11 @@ internal class BaseSearchCommand : BaseCommand<SearchCommandArgs>, IFilterableCo
 
         internal BaseSearchCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName)
-            : base(host, logger, callbacks, commandName, SymbolStrings.Command_Search_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_Search_Description)
         {
             ParentCommand = parentCommand;
             Filters = SetupFilterOptions(SupportedFilters);
@@ -54,7 +54,11 @@ internal BaseSearchCommand(
 
         internal NewCommand ParentCommand { get; }
 
-        protected override async Task<NewCommandStatus> ExecuteAsync(SearchCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected override async Task<NewCommandStatus> ExecuteAsync(
+            SearchCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
             //we need to await, otherwise templatePackageManager will be disposed.
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
index c83a2dbf41..6dfdae4209 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
@@ -11,8 +11,8 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal class LegacySearchCommand : BaseSearchCommand
     {
-        public LegacySearchCommand(NewCommand parentCommand, ITemplateEngineHost host, ITelemetryLogger logger, NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "--search")
+        public LegacySearchCommand(NewCommand parentCommand, Func<ParseResult, ITemplateEngineHost> hostBuilder, Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder, NewCommandCallbacks callbacks)
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "--search")
         {
             this.IsHidden = true;
             AddValidator(ValidateParentCommandArguments);
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs
index 5fa6b86512..65f93cb171 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs
@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -11,10 +12,10 @@ internal class SearchCommand : BaseSearchCommand
     {
         public SearchCommand(
                 NewCommand parentCommand,
-                ITemplateEngineHost host,
-                ITelemetryLogger logger,
+                Func<ParseResult, ITemplateEngineHost> hostBuilder,
+                Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
                 NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "search")
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "search")
         {
             parentCommand.AddNoLegacyUsageValidators(this);
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
index 5f5e292075..e07aa06e8e 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
@@ -14,11 +14,11 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     internal class BaseUninstallCommand : BaseCommand<UninstallCommandArgs>
     {
         internal BaseUninstallCommand(
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName)
-            : base(host, logger, callbacks, commandName, SymbolStrings.Command_Uninstall_Description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, SymbolStrings.Command_Uninstall_Description)
         {
             this.AddArgument(NameArgument);
         }
@@ -29,11 +29,15 @@ internal BaseUninstallCommand(
             Arity = new ArgumentArity(0, 99)
         };
 
-        protected override async Task<NewCommandStatus> ExecuteAsync(UninstallCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected override async Task<NewCommandStatus> ExecuteAsync(
+            UninstallCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
             TemplatePackageCoordinator templatePackageCoordinator = new TemplatePackageCoordinator(
-                TelemetryLogger,
+                telemetryLogger,
                 environmentSettings,
                 templatePackageManager);
 
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs
index 2a09dbd08a..a28c5acfc2 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs
@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -11,10 +12,10 @@ internal class LegacyUninstallCommand : BaseUninstallCommand
     {
         public LegacyUninstallCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(host, logger, callbacks, "--uninstall")
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "--uninstall")
         {
             this.IsHidden = true;
             this.AddAlias("-u");
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs
index 9123a56cb4..bbc0e89b88 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs
@@ -3,6 +3,7 @@
 
 #nullable enable
 
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -11,10 +12,10 @@ internal class UninstallCommand : BaseUninstallCommand
     {
         public UninstallCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(host, logger, callbacks, "uninstall")
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, "uninstall")
         {
             parentCommand.AddNoLegacyUsageValidators(this);
         }
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
index 18a1fbcde7..0034a59203 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
@@ -15,12 +15,12 @@ internal class BaseUpdateCommand : BaseCommand<UpdateCommandArgs>
     {
         internal BaseUpdateCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks,
             string commandName,
             string description)
-            : base(host, logger, callbacks, commandName, description)
+            : base(hostBuilder, telemetryLoggerBuilder, callbacks, commandName, description)
         {
             ParentCommand = parentCommand;
             this.AddOption(InteractiveOption);
@@ -33,11 +33,15 @@ internal BaseUpdateCommand(
 
         protected NewCommand ParentCommand { get; }
 
-        protected override async Task<NewCommandStatus> ExecuteAsync(UpdateCommandArgs args, IEngineEnvironmentSettings environmentSettings, InvocationContext context)
+        protected override async Task<NewCommandStatus> ExecuteAsync(
+            UpdateCommandArgs args,
+            IEngineEnvironmentSettings environmentSettings,
+            ITelemetryLogger telemetryLogger,
+            InvocationContext context)
         {
             using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
             TemplatePackageCoordinator templatePackageCoordinator = new TemplatePackageCoordinator(
-                TelemetryLogger,
+                telemetryLogger,
                 environmentSettings,
                 templatePackageManager);
 
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
index 1db0387c05..0ce8063cd8 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
@@ -4,6 +4,7 @@
 #nullable enable
 
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -12,10 +13,10 @@ internal class LegacyUpdateApplyCommand : BaseUpdateCommand
     {
         public LegacyUpdateApplyCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "--update-apply", SymbolStrings.Command_Legacy_Update_Check_Description)
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "--update-apply", SymbolStrings.Command_Legacy_Update_Check_Description)
         {
             this.IsHidden = true;
             parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
index dc06edce90..03b729de4d 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
@@ -4,6 +4,7 @@
 #nullable enable
 
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
@@ -12,10 +13,10 @@ internal class LegacyUpdateCheckCommand : BaseUpdateCommand
     {
         public LegacyUpdateCheckCommand(
             NewCommand parentCommand,
-            ITemplateEngineHost host,
-            ITelemetryLogger logger,
+            Func<ParseResult, ITemplateEngineHost> hostBuilder,
+            Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
             NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "--update-check", SymbolStrings.Command_Update_Description)
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "--update-check", SymbolStrings.Command_Update_Description)
         {
             this.IsHidden = true;
             parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
diff --git a/src/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs b/src/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
index b52412a900..1819272a47 100644
--- a/src/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
+++ b/src/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
@@ -13,10 +13,10 @@ internal class UpdateCommand : BaseUpdateCommand
     {
         public UpdateCommand(
                 NewCommand parentCommand,
-                ITemplateEngineHost host,
-                ITelemetryLogger logger,
+                Func<ParseResult, ITemplateEngineHost> hostBuilder,
+                Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder,
                 NewCommandCallbacks callbacks)
-            : base(parentCommand, host, logger, callbacks, "update", SymbolStrings.Command_Update_Description)
+            : base(parentCommand, hostBuilder, telemetryLoggerBuilder, callbacks, "update", SymbolStrings.Command_Update_Description)
         {
             parentCommand.AddNoLegacyUsageValidators(this);
             this.AddOption(CheckOnlyOption);
diff --git a/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.Designer.cs b/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.Designer.cs
index feb49016b5..422d3a1351 100644
--- a/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.Designer.cs
+++ b/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.Designer.cs
@@ -1059,6 +1059,15 @@ internal static string NoPrimaryOutputsToRestore {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to No templates installed..
+        /// </summary>
+        internal static string NoTemplatesFound {
+            get {
+                return ResourceManager.GetString("NoTemplatesFound", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to No templates found matching: {0}..
         /// </summary>
diff --git a/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.resx b/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.resx
index 4b8bafd14a..54ed141c19 100644
--- a/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.resx
+++ b/src/Microsoft.TemplateEngine.Cli/LocalizableStrings.resx
@@ -767,4 +767,7 @@ The header is followed by the list of parameters and their errors (might be seve
     <value>Default value for argument missing for option: '{0}'.</value>
     <comment>{0} - option name</comment>
   </data>
-</root>
+  <data name="NoTemplatesFound" xml:space="preserve">
+    <value>No templates installed.</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/src/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs b/src/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
index a59ea40029..90d0b07241 100644
--- a/src/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
+++ b/src/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
@@ -4,6 +4,7 @@
 #nullable enable
 
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Cli.Commands;
 
@@ -11,18 +12,18 @@ namespace Microsoft.TemplateEngine.Cli
 {
     public static class NewCommandFactory
     {
-        public static Command Create(string commandName, ITemplateEngineHost host, ITelemetryLogger telemetryLogger, NewCommandCallbacks callbacks)
+        public static Command Create(string commandName, Func<ParseResult, ITemplateEngineHost> hostBuilder, Func<ParseResult, ITelemetryLogger> telemetryLoggerBuilder, NewCommandCallbacks callbacks)
         {
             if (string.IsNullOrWhiteSpace(commandName))
             {
                 throw new ArgumentException($"'{nameof(commandName)}' cannot be null or whitespace.", nameof(commandName));
             }
 
-            _ = host ?? throw new ArgumentNullException(nameof(host));
-            _ = telemetryLogger ?? throw new ArgumentNullException(nameof(telemetryLogger));
+            _ = hostBuilder ?? throw new ArgumentNullException(nameof(hostBuilder));
+            _ = telemetryLoggerBuilder ?? throw new ArgumentNullException(nameof(telemetryLoggerBuilder));
             _ = callbacks ?? throw new ArgumentNullException(nameof(callbacks));
 
-            return new NewCommand(commandName, host, telemetryLogger, callbacks);
+            return new NewCommand(commandName, hostBuilder, telemetryLoggerBuilder, callbacks);
         }
     }
 }
diff --git a/src/Microsoft.TemplateEngine.Cli/PublicAPI.Unshipped.txt b/src/Microsoft.TemplateEngine.Cli/PublicAPI.Unshipped.txt
index f261afade6..ff4adc0081 100644
--- a/src/Microsoft.TemplateEngine.Cli/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.TemplateEngine.Cli/PublicAPI.Unshipped.txt
@@ -3,7 +3,7 @@ Microsoft.TemplateEngine.Cli.Commands.ICustomHelp.CustomHelpLayout() -> System.C
 Microsoft.TemplateEngine.Cli.NewCommandCallbacks
 Microsoft.TemplateEngine.Cli.NewCommandCallbacks.NewCommandCallbacks() -> void
 Microsoft.TemplateEngine.Cli.NewCommandFactory
-static Microsoft.TemplateEngine.Cli.NewCommandFactory.Create(string! commandName, Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost! host, Microsoft.TemplateEngine.Cli.ITelemetryLogger! telemetryLogger, Microsoft.TemplateEngine.Cli.NewCommandCallbacks! callbacks) -> System.CommandLine.Command!
+static Microsoft.TemplateEngine.Cli.NewCommandFactory.Create(string! commandName, System.Func<System.CommandLine.Parsing.ParseResult!, Microsoft.TemplateEngine.Abstractions.ITemplateEngineHost!>! hostBuilder, System.Func<System.CommandLine.Parsing.ParseResult!, Microsoft.TemplateEngine.Cli.ITelemetryLogger!>! telemetryLoggerBuilder, Microsoft.TemplateEngine.Cli.NewCommandCallbacks! callbacks) -> System.CommandLine.Command!
 ~Microsoft.TemplateEngine.Cli.NewCommandCallbacks.OnFirstRun.get -> System.Action<Microsoft.TemplateEngine.Abstractions.IEngineEnvironmentSettings>
 ~Microsoft.TemplateEngine.Cli.NewCommandCallbacks.OnFirstRun.set -> void
 ~Microsoft.TemplateEngine.Cli.NewCommandCallbacks.RestoreProject.get -> System.Func<string, bool>
diff --git a/src/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs b/src/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
index c7907d1f3a..3aee2d595b 100644
--- a/src/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
+++ b/src/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
@@ -71,6 +71,20 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
             }
             else
             {
+                //if there is no criteria and filters it means that dotnet new list was run but there is no templates installed.
+                if (args.ListNameCriteria == null && !args.AppliedFilters.Any())
+                {
+                    //No templates installed.
+                    Reporter.Output.WriteLine(LocalizableStrings.NoTemplatesFound);
+                    Reporter.Output.WriteLine();
+                    // To search for the templates on NuGet.org, run:
+                    Reporter.Output.WriteLine(LocalizableStrings.SearchTemplatesCommand);
+                    Reporter.Output.WriteCommand(CommandExamples.SearchCommandExample(args.CommandName, usePlaceholder: true));
+                    Reporter.Output.WriteLine();
+                    return NewCommandStatus.Success;
+                }
+
+                // at least one criteria was specified.
                 // No templates found matching the following input parameter(s): {0}.
                 Reporter.Error.WriteLine(
                     string.Format(
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.cs.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.cs.xlf
index 26dd85e24d..e1ad7c91d0 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.cs.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.cs.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Nejsou k dispozici žádné primární výstupy, které by se měly obnovit.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Nenašly se žádné šablony, které by odpovídaly tomuto hledání: {0}</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.de.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.de.xlf
index d22cb14946..1763b72179 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.de.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.de.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Es sind keine primären Ausgaben zum Wiederherstellen vorhanden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Keine Vorlagen gefunden, die "{0}" entsprechen.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.es.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.es.xlf
index d059239437..611c9be4c5 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.es.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.es.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">No hay ningún resultado principal para restaurar.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">No se encontró ninguna plantilla que coincida con: {0}</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.fr.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.fr.xlf
index b85f4b99c6..13a24d104d 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.fr.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.fr.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Aucune sortie principale à restaurer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Aucun modèle trouvé correspondant : {0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.it.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.it.xlf
index 72c139e779..a38e5f6e8d 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.it.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.it.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Nessun output primario da ripristinare.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Nessun modello corrispondente trovato: {0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ja.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ja.xlf
index 60ea965026..2ec3455cb9 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ja.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ja.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">復元するプライマリ出力はありません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">テンプレートが見つかりません: {0}。</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ko.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ko.xlf
index 251979e5f4..30702083b0 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ko.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ko.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">복원할 기본 출력이 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">일치하는 템플릿이 없음:{0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pl.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pl.xlf
index 5dedad572c..a7c8bf4237 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pl.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pl.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Brak podstawowych danych wyjściowych do przywrócenia.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Nie stwierdzono dopasowania żadnych szablonów: {0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pt-BR.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pt-BR.xlf
index cb98bc8026..f141e9bd1b 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pt-BR.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.pt-BR.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Nenhuma Saída Primária a ser restaurada.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Nenhum modelo encontrado: {0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ru.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ru.xlf
index 071b3689a8..715d774ca6 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ru.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.ru.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Нет основных выходных данных для восстановления.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Соответствующие шаблоны не найдены: {0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.tr.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.tr.xlf
index 39ee2bfad1..bbc903fd0f 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.tr.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.tr.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">Geri yüklenecek Birincil Çıkış yok.</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">Eşleşen şablon bulunamadı: {0}.</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hans.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hans.xlf
index 26901c6f76..082a1a080c 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hans.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hans.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">没有要还原的主输出。</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">找不到匹配的模板: {0}。</target>
diff --git a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hant.xlf b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hant.xlf
index 9ae473b098..32a0adc803 100644
--- a/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hant.xlf
+++ b/src/Microsoft.TemplateEngine.Cli/xlf/LocalizableStrings.zh-Hant.xlf
@@ -573,6 +573,11 @@ The header is followed by the list of parameters and their errors (might be seve
         <target state="translated">沒有要還原的主要輸出。</target>
         <note />
       </trans-unit>
+      <trans-unit id="NoTemplatesFound">
+        <source>No templates installed.</source>
+        <target state="new">No templates installed.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="NoTemplatesMatchingInputParameters">
         <source>No templates found matching: {0}.</source>
         <target state="translated">找不到符合的範本: {0}。</target>
diff --git a/src/dotnet-new3/CompleteCommand.cs b/src/dotnet-new3/CompleteCommand.cs
index 65f5a8ff4f..eb5dd94053 100644
--- a/src/dotnet-new3/CompleteCommand.cs
+++ b/src/dotnet-new3/CompleteCommand.cs
@@ -41,19 +41,8 @@ public Task<int> Run(ParseResult result)
                     input += " ";
                 }
 
-                Command new3Command = new New3Command();
-
-                //help is disabled for pre-parsing and should be handled by NewCommand instead.
-                ParseResult preParseResult = ParserFactory
-                    .CreateParser(new3Command, disableHelp: true)
-                    .Parse(input);
-
-                DefaultTemplateEngineHost host = HostFactory.CreateHost(preParseResult.GetValueForOption(New3Command.DebugDisableBuiltInTemplatesOption));
-                ITelemetryLogger telemetryLogger = new TelemetryLogger(null, preParseResult.GetValueForOption(New3Command.DebugEmitTelemetryOption));
-                string[] remainingArgs = preParseResult.GetValueForArgument(New3Command.RemainingTokensArgument) ?? Array.Empty<string>();
-
-                Command newCommand = NewCommandFactory.Create(new3Command.Name, host, telemetryLogger, new NewCommandCallbacks());
-                ParseResult newCommandResult = ParserFactory.CreateParser(newCommand).Parse(remainingArgs, rawInput: input);
+                Command newCommand = New3CommandFactory.Create();
+                ParseResult newCommandResult = ParserFactory.CreateParser(newCommand).Parse(input);
                 foreach (CompletionItem suggestion in newCommandResult.GetCompletions(position).Distinct())
                 {
                     Console.WriteLine(suggestion.Label);
diff --git a/src/dotnet-new3/New3Command.cs b/src/dotnet-new3/New3Command.cs
deleted file mode 100644
index 9c15621ccb..0000000000
--- a/src/dotnet-new3/New3Command.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.Parsing;
-using Microsoft.TemplateEngine.Cli;
-using Microsoft.TemplateEngine.Edge;
-
-namespace Dotnet_new3
-{
-    internal class New3Command : Command
-    {
-        private static readonly Option<bool> _debugEmitTelemetryOption = new("--debug:emit-telemetry", "Enable telemetry")
-        {
-            IsHidden = true
-        };
-
-        private static readonly Option<bool> _debugDisableBuiltInTemplatesOption = new("--debug:disable-sdk-templates", "Disable built-in templates")
-        {
-            IsHidden = true
-        };
-
-        private static readonly Argument<string[]> _remainingTokensArgument = new Argument<string[]>()
-        {
-            Arity = new ArgumentArity(0, 999)
-        };
-
-        internal New3Command() : base("new3", "Pre-parse command for dotnet new3")
-        {
-            this.AddOption(DebugEmitTelemetryOption);
-            this.AddOption(DebugDisableBuiltInTemplatesOption);
-            this.AddArgument(RemainingTokensArgument);
-            this.AddCommand(new CompleteCommand());
-            this.SetHandler((ParseResult parseResult) => Run(parseResult));
-        }
-
-        internal static Option<bool> DebugEmitTelemetryOption => _debugEmitTelemetryOption;
-
-        internal static Option<bool> DebugDisableBuiltInTemplatesOption => _debugDisableBuiltInTemplatesOption;
-
-        internal static Argument<string[]> RemainingTokensArgument => _remainingTokensArgument;
-
-        internal Task<int> Run(ParseResult result)
-        {
-            DefaultTemplateEngineHost host = HostFactory.CreateHost(result.GetValueForOption(DebugDisableBuiltInTemplatesOption));
-            ITelemetryLogger telemetryLogger = new TelemetryLogger(null, result.GetValueForOption(DebugEmitTelemetryOption));
-            string[] remainingArgs = result.GetValueForArgument(RemainingTokensArgument) ?? Array.Empty<string>();
-
-            Command newCommand = NewCommandFactory.Create(Name, host, telemetryLogger, new NewCommandCallbacks());
-
-            return ParserFactory.CreateParser(newCommand).Parse(remainingArgs).InvokeAsync();
-        }
-    }
-}
diff --git a/src/dotnet-new3/New3CommandFactory.cs b/src/dotnet-new3/New3CommandFactory.cs
new file mode 100644
index 0000000000..d2359da93e
--- /dev/null
+++ b/src/dotnet-new3/New3CommandFactory.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using System.CommandLine.Parsing;
+using Microsoft.TemplateEngine.Cli;
+
+namespace Dotnet_new3
+{
+    internal static class New3CommandFactory
+    {
+        private const string CommandName = "new3";
+
+        private static readonly Option<bool> _debugEmitTelemetryOption = new("--debug:emit-telemetry", "Enable telemetry")
+        {
+            IsHidden = true
+        };
+
+        private static readonly Option<bool> _debugDisableBuiltInTemplatesOption = new("--debug:disable-sdk-templates", "Disable built-in templates")
+        {
+            IsHidden = true
+        };
+
+        internal static Command Create()
+        {
+            Command newCommand = NewCommandFactory.Create(
+                CommandName,
+                (ParseResult parseResult) => HostFactory.CreateHost(parseResult.GetValueForOption(_debugDisableBuiltInTemplatesOption)),
+                (ParseResult parseResult) => new TelemetryLogger(null, parseResult.GetValueForOption(_debugEmitTelemetryOption)),
+                new NewCommandCallbacks());
+
+            newCommand.AddGlobalOption(_debugEmitTelemetryOption);
+            newCommand.AddGlobalOption(_debugDisableBuiltInTemplatesOption);
+            newCommand.AddCommand(new CompleteCommand());
+            return newCommand;
+        }
+    }
+}
diff --git a/src/dotnet-new3/Program.cs b/src/dotnet-new3/Program.cs
index 602a861dc0..d3817a9c7d 100644
--- a/src/dotnet-new3/Program.cs
+++ b/src/dotnet-new3/Program.cs
@@ -4,6 +4,7 @@
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.Text;
+using Microsoft.TemplateEngine.Cli;
 
 namespace Dotnet_new3
 {
@@ -22,7 +23,9 @@ public static Task<int> Main(string[] args)
                     Console.OutputEncoding = Encoding.UTF8;
                 }
             }
-            return ParserFactory.CreateParser(new New3Command(), disableHelp: true).Parse(args).InvokeAsync();
+
+            Command newCommand = New3CommandFactory.Create();
+            return ParserFactory.CreateParser(newCommand).Parse(args).InvokeAsync();
         }
     }
 }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs
index 09944d34a0..277e9a1efb 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs
@@ -39,7 +39,7 @@ public void UniqueNameMatchesCorrectly()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new console2");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -66,7 +66,7 @@ public Task FailedToResolveTemplate_WhenMultipleLanguagesAreFound()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new console");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -93,7 +93,7 @@ public void DefaultLanguageDisambiguates()
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new console");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -121,7 +121,7 @@ public void InputLanguageIsPreferredOverDefault()
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --language L2");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -147,7 +147,7 @@ public void TemplatesAreSameLanguage()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -175,7 +175,7 @@ public void HasLanguageMismatch()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --language L2");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -199,7 +199,7 @@ public void HasTypeMismatch()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --type item");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -222,7 +222,7 @@ public void HasBaselineMismatch()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --baseline core");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -246,7 +246,7 @@ public void HasMultipleMismatches()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --language L2 --type item --baseline core");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -276,7 +276,7 @@ public void HasTypeMismatch_HasGroupLanguageMatch()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --language L2 --type item");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -314,7 +314,7 @@ public void OtherParameterMatch_Text()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --langVersion ver");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -352,7 +352,7 @@ public void OtherParameterMatch_Choice()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --framework netcoreapp1.0");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -391,7 +391,7 @@ public void OtherParameterDoesNotExist()
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new console --do-not-exist");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs
index 360b291b72..c3d3f35ae3 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs
@@ -73,7 +73,7 @@ public void CanShowUsage()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             StringWriter sw = new StringWriter();
             HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), instantiateCommand, sw);
@@ -87,7 +87,7 @@ public void CanShowUsage_ForMultipleShortNames()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             StringWriter sw = new StringWriter();
             HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), instantiateCommand, sw);
@@ -108,7 +108,7 @@ public Task CanShowCommandOptions_Basic()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -132,7 +132,7 @@ public Task CanShowCommandOptions_Language()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -156,7 +156,7 @@ public Task CanShowCommandOptions_Type()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -180,7 +180,7 @@ public void CanShowCommandOptions_NoOptions()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -205,7 +205,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -232,7 +232,7 @@ public Task CanShowTemplateOptions_MultipleTemplate_CombinedChoice()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand1 = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]);
@@ -258,7 +258,7 @@ public Task CanShowTemplateOptions_SingleTemplate_NonChoice()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -287,7 +287,7 @@ public Task CanShowTemplateOptions_MultipleTemplate_MultipleParams()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand1 = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]);
@@ -313,7 +313,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice_Required()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -338,7 +338,7 @@ public void CanShowTemplateOptions_RequiredIsNotShownWhenDefaultValueIsGiven()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -362,7 +362,7 @@ public Task CanShowHintsForOtherTemplates()
 
             ITemplateEngineHost host = TestHost.GetVirtualHost();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             StringWriter sw = new StringWriter();
@@ -384,7 +384,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice_ShortenedUsage_FirstTwo
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -409,7 +409,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice_ShortenedUsage()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
index 4aaa513baf..5e73441a25 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
@@ -17,7 +17,7 @@ public class InstallTests
         public void Install_CanParseAddSourceOption(string optionName)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new install source {optionName} my-custom-source");
             InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -32,7 +32,7 @@ public void Install_CanParseAddSourceOption(string optionName)
         public void Install_Error_NoArguments()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new install");
 
@@ -46,7 +46,7 @@ public void Install_Error_NoArguments()
         public void Install_Legacy_Error_NoArguments()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new --install --interactive");
 
@@ -62,7 +62,7 @@ public void Install_Legacy_Error_NoArguments()
         public void Install_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -77,7 +77,7 @@ public void Install_CanParseAddSourceOption_MultipleEntries(string testCase)
         public void Install_CanParseInteractiveOption()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new install source --interactive");
             InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -98,7 +98,7 @@ public void Install_CanParseInteractiveOption()
         public void Install_CanParseMultipleArgs()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new install source1 source2");
             InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -115,7 +115,7 @@ public void Install_CanParseMultipleArgs()
         public void Install_Legacy_CanParseAddSourceOption(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -132,7 +132,7 @@ public void Install_Legacy_CanParseAddSourceOption(string testCase)
         public void Install_Legacy_CanParseInteractiveOption(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -148,7 +148,7 @@ public void Install_Legacy_CanParseInteractiveOption(string testCase)
         public void Install_Legacy_CanParseMultipleArgs(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
              
             var parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -165,7 +165,7 @@ public void Install_Legacy_CanParseMultipleArgs(string testCase)
         public void Install_Legacy_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new InstallCommandArgs((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -186,7 +186,7 @@ public void Install_Legacy_CanParseAddSourceOption_MultipleEntries(string testCa
         public void Install_CanReturnParseError(string command, string expectedInvalidTokens)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             var errorMessages = parseResult.Errors.Select(error => error.Message);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs
index 26546ce1f8..f8c07f2ecf 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs
@@ -154,7 +154,7 @@ internal void CanEvaluateInvalidParameters(string command, MockTemplateInfo[] te
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager templatePackageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
index 89a4a1b6b7..e510da194f 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
@@ -23,7 +23,7 @@ public partial class InstantiateTests
         public void Create_CanParseTemplateWithOptions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse("new create console --framework net5.0");
             InstantiateCommandArgs args = new InstantiateCommandArgs((InstantiateCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -52,7 +52,7 @@ internal void Create_CanEvaluateTemplateToRun(string command, string templateSet
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -75,7 +75,7 @@ internal void Create_CanParseNameOption(string command, string? expectedValue)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -108,7 +108,7 @@ internal void Create_CanParseTemplateOptions(string command, string parameterNam
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());  
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());  
             var parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -143,7 +143,7 @@ internal void Create_CanParseChoiceTemplateOptions(string command, string parame
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -185,7 +185,7 @@ internal void Create_CanDetectParseErrorsTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -219,7 +219,7 @@ internal void Create_CanDetectParseErrorsChoiceTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($" new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -246,7 +246,7 @@ internal void Create_CanEvaluateTemplateWithSubcommandShortName(string command,
             ITemplateEngineHost host = TestHost.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
index 32a008e7b5..5d778f215d 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
@@ -23,7 +23,7 @@ public partial class InstantiateTests
         public void Instantiate_CanParseTemplateWithOptions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse("new console --framework net5.0");
             InstantiateCommandArgs args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -226,7 +226,7 @@ internal void CanEvaluateTemplateToRun(string command, string templateSet, strin
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -257,7 +257,7 @@ internal void CanParseNameOption(string command, string? expectedValue)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -323,7 +323,7 @@ internal void CanParseTemplateOptions(string command, string parameterName, stri
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -367,7 +367,7 @@ internal void CanParseChoiceTemplateOptions(string command, string parameterName
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -438,7 +438,7 @@ internal void CanDetectParseErrorsTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -481,7 +481,7 @@ internal void CanDetectParseErrorsChoiceTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new {command}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -506,7 +506,7 @@ internal void DoNotAddAllowScriptOptionForTemplate()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -540,7 +540,7 @@ internal void CanParseAllowScriptsOption(string command, AllowRunScripts? result
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse(command);
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -574,7 +574,7 @@ public void AllTemplatesInGroupUseAllShortNamesForResolution(string shortName)
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($"new {shortName}");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -603,7 +603,7 @@ public void ExplicitLanguageChoiceIsHonoredWithMultipleShortNames(string shortNa
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             string command = $"new {shortName} --language F#";
@@ -635,7 +635,7 @@ public void ChoiceValueDisambiguatesMatchesWithMultipleShortNames(string name, s
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             string command = $"new {name} --foo {fooChoice}";
@@ -666,7 +666,7 @@ public void ParameterExistenceDisambiguatesMatchesWithMultipleShortNames(string
             ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
 
             string command = $"new {name} --{paramName} {paramValue}";
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
index d733b66b40..f8f9410846 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
@@ -83,7 +83,7 @@ public void List_CanParseFilterOption(string command, string expectedFilter)
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             ListCommandArgs args = new ListCommandArgs((BaseListCommand)parseResult.CommandResult.Command, parseResult);
@@ -124,7 +124,7 @@ public void List_CanParseFilterOptionWithoutMainCriteria(string command, string
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             ListCommandArgs args = new ListCommandArgs((BaseListCommand)parseResult.CommandResult.Command, parseResult);
@@ -140,7 +140,7 @@ public void List_CanParseFilterOptionWithoutMainCriteria(string command, string
         public void List_CannotParseMultipleArgs(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -152,7 +152,7 @@ public void List_CannotParseMultipleArgs(string command)
         public void List_CannotParseArgsAtNewLevel()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new smth list");
 
@@ -169,7 +169,7 @@ public void List_CannotParseArgsAtNewLevel()
         public void List_CannotParseOptionsAtNewLevel(string command, string expectedFilter)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -181,7 +181,7 @@ public void List_CannotParseOptionsAtNewLevel(string command, string expectedFil
         public void List_Legacy_CannotParseArgsAtBothLevels()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new smth --list smth-else");
 
@@ -196,7 +196,7 @@ public void List_Legacy_CannotParseArgsAtBothLevels()
         public void List_CanParseColumnsAll(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -216,7 +216,7 @@ public void List_CanParseColumnsAll(string command)
         public void List_CanParseColumns(string command, string[] expectedColumns)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -237,7 +237,7 @@ public void List_CanParseColumns(string command, string[] expectedColumns)
         public void List_CannotParseUnknownColumns(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -253,7 +253,7 @@ public void List_CannotParseUnknownColumns(string command)
         public void List_HandleParseErrors(string command, string expectedInvalidTokens)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             var errorMessages = parseResult.Errors.Select(error => error.Message);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
index 5008b89590..5f30cfd241 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
@@ -3,10 +3,13 @@
 
 #nullable enable
 
+using System.CommandLine;
 using System.CommandLine.Builder;
 using System.CommandLine.Completions;
 using System.CommandLine.Parsing;
+using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Cli.Commands;
+using Microsoft.TemplateEngine.TestHelper;
 using Xunit;
 
 namespace Microsoft.TemplateEngine.Cli.UnitTests.ParserTests
@@ -54,5 +57,117 @@ public void CompletionItemCompareIsAsExpected()
                  new CompletionItem("my-label", kind: "Argument", sortText: "sort-text2", insertText: "insert-text2", documentation: "doc2", detail: "det2"));
 
         }
+
+        [Theory]
+        [InlineData("new --debug:attach", "--debug:attach")]
+        [InlineData("new --debug:attach console", "--debug:attach")]
+        [InlineData("new --debug:reinit", "--debug:reinit")]
+        [InlineData("new --debug:ephemeral-hive", "--debug:ephemeral-hive")]
+        [InlineData("new --debug:virtual-hive", "--debug:ephemeral-hive")]
+        [InlineData("new --debug:rebuildcache", "--debug:rebuild-cache")]
+        [InlineData("new --debug:rebuild-cache", "--debug:rebuild-cache")]
+        [InlineData("new --debug:show-config", "--debug:show-config")]
+        [InlineData("new --debug:showconfig", "--debug:show-config")]
+
+        public void DebugFlagCanBeParsedOnNewLevel(string command, string option)
+        {
+             Dictionary<string, Func<GlobalArgs, bool>> optionsMap = new Dictionary<string, Func<GlobalArgs, bool>>()
+            {
+                { "--debug:attach", args => args.DebugAttach },
+                { "--debug:ephemeral-hive", args => args.DebugVirtualizeSettings },
+                { "--debug:reinit", args => args.DebugReinit },
+                { "--debug:rebuild-cache", args => args.DebugRebuildCache },
+                { "--debug:show-config", args => args.DebugShowConfig }
+            };
+
+            ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var parseResult = ParserFactory.CreateParser(myCommand).Parse(command);
+            NewCommandArgs args = new NewCommandArgs(myCommand, parseResult);
+
+            Assert.True(optionsMap[option](args));
+        }
+
+        [Theory]
+        [InlineData("new install source --debug:attach", "--debug:attach")]
+        [InlineData("new install source --debug:attach --add-source s1", "--debug:attach")]
+        [InlineData("new install --debug:reinit source", "--debug:reinit")]
+        [InlineData("new install source --debug:ephemeral-hive", "--debug:ephemeral-hive")]
+        [InlineData("new install source --debug:virtual-hive", "--debug:ephemeral-hive")]
+        [InlineData("new install source --debug:rebuildcache", "--debug:rebuild-cache")]
+        [InlineData("new install source --debug:rebuild-cache", "--debug:rebuild-cache")]
+        [InlineData("new install source --debug:show-config", "--debug:show-config")]
+        [InlineData("new install source --debug:showconfig", "--debug:show-config")]
+
+        public void DebugFlagCanBeParsedOnSubcommandLevel(string command, string option)
+        {
+            Dictionary<string, Func<GlobalArgs, bool>> optionsMap = new Dictionary<string, Func<GlobalArgs, bool>>()
+            {
+                { "--debug:attach", args => args.DebugAttach },
+                { "--debug:ephemeral-hive", args => args.DebugVirtualizeSettings },
+                { "--debug:reinit", args => args.DebugReinit },
+                { "--debug:rebuild-cache", args => args.DebugRebuildCache },
+                { "--debug:show-config", args => args.DebugShowConfig }
+            };
+
+            ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var parseResult = ParserFactory.CreateParser(myCommand).Parse(command);
+            InstallCommandArgs args = new InstallCommandArgs((InstallCommand)parseResult.CommandResult.Command, parseResult);
+
+            Assert.True(optionsMap[option](args));
+        }
+
+        [Theory]
+        [InlineData("new console  --framework net5.0 --flag --debug:attach", "--debug:attach")]
+        [InlineData("new console --framework net5.0 --debug:attach --flag", "--debug:attach")]
+        [InlineData("new console --debug:reinit --framework net5.0 --flag", "--debug:reinit")]
+        [InlineData("new console --framework net5.0 --debug:ephemeral-hive --flag", "--debug:ephemeral-hive")]
+        [InlineData("new console --framework net5.0 --debug:virtual-hive --flag", "--debug:ephemeral-hive")]
+        [InlineData("new console --framework net5.0 --debug:rebuildcache --flag", "--debug:rebuild-cache")]
+        [InlineData("new console --framework net5.0 --debug:rebuild-cache --flag", "--debug:rebuild-cache")]
+        [InlineData("new console --framework net5.0 --debug:show-config --flag", "--debug:show-config")]
+        [InlineData("new console --framework net5.0 --debug:showconfig --flag", "--debug:show-config")]
+
+        public void DebugFlagCanBeParsedOnTemplateSubcommandLevel(string command, string option)
+        {
+            Dictionary<string, Func<GlobalArgs, bool>> optionsMap = new Dictionary<string, Func<GlobalArgs, bool>>()
+            {
+                { "--debug:attach", args => args.DebugAttach },
+                { "--debug:ephemeral-hive", args => args.DebugVirtualizeSettings },
+                { "--debug:reinit", args => args.DebugReinit },
+                { "--debug:rebuild-cache", args => args.DebugRebuildCache },
+                { "--debug:show-config", args => args.DebugShowConfig }
+            };
+
+            ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
+            InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
+            var parseResult = instantiateCommand.Parse(command);
+            InstantiateCommandArgs args = new InstantiateCommandArgs(instantiateCommand, parseResult);
+
+            Assert.True(optionsMap[option](args));
+            Assert.Equal("console", args.ShortName);
+            Assert.Equal(new[] { "--framework", "net5.0", "--flag" }, args.RemainingArguments);
+        }
+
+        [Fact]
+        public void ManuallyAddedOptionIsPreservedOnTemplateSubcommandLevel()
+        {
+            ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
+
+            var customOption = new Option<string>("--newOption");
+            myCommand.AddGlobalOption(customOption);
+
+            InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
+            var parseResult = instantiateCommand.Parse("new console --newOption val");
+            InstantiateCommandArgs args = new InstantiateCommandArgs(instantiateCommand, parseResult);
+
+            Assert.NotNull(args.ParseResult);
+            Assert.Equal("console", args.ShortName);
+            Assert.Empty(args.RemainingArguments);
+            Assert.Equal("val", args.ParseResult.GetValueForOption(customOption));
+        }
     }
 }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
index 84379d8bb8..37fecbd66f 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
@@ -65,7 +65,7 @@ public void Search_CanParseFilterOption(string command, string expectedFilter)
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
@@ -99,7 +99,7 @@ public void Search_CanParseFilterOptionWithoutMainCriteria(string command, strin
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             SearchCommandArgs args = new SearchCommandArgs((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
@@ -115,7 +115,7 @@ public void Search_CanParseFilterOptionWithoutMainCriteria(string command, strin
         public void Search_CannotParseMultipleArgs(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -127,7 +127,7 @@ public void Search_CannotParseMultipleArgs(string command)
         public void Search_CannotParseArgsAtNewLevel()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new smth search");
 
@@ -145,7 +145,7 @@ public void Search_CannotParseArgsAtNewLevel()
         public void Search_CannotParseOptionsAtNewLevel(string command, string expectedFilter)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -157,7 +157,7 @@ public void Search_CannotParseOptionsAtNewLevel(string command, string expectedF
         public void Search_Legacy_CannotParseArgsAtBothLevels()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new smth --search smth-else");
 
@@ -173,7 +173,7 @@ public void Search_Legacy_CannotParseArgsAtBothLevels()
         public void Search_HandleParseErrors(string command, string expectedInvalidTokens)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             var errorMessages = parseResult.Errors.Select(error => error.Message);
@@ -195,7 +195,7 @@ public void Search_HandleParseErrors(string command, string expectedInvalidToken
         public void Search_CanParseColumnsAll(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -215,7 +215,7 @@ public void Search_CanParseColumnsAll(string command)
         public void Search_CanParseColumns(string command, string[] expectedColumns)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
@@ -236,7 +236,7 @@ public void Search_CanParseColumns(string command, string[] expectedColumns)
         public void Search_CannotParseUnknownColumns(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
 
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
index a06f98d25a..cda9af6308 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
@@ -24,7 +24,7 @@ public TabCompletionTests (VerifyFixture verifySettings)
         public Task RootCommand_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new ");
             var result = parseResult.GetCompletions().ToArray();
@@ -36,7 +36,7 @@ public Task RootCommand_GetAllSuggestions()
         public Task RootCommand_GetStartsWtihSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new c");
             var result = parseResult.GetCompletions().ToArray();
@@ -48,7 +48,7 @@ public Task RootCommand_GetStartsWtihSuggestions()
         public Task Install_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new install ");
             var result = parseResult.GetCompletions().ToArray();
@@ -60,7 +60,7 @@ public Task Install_GetAllSuggestions()
         public Task Uninstall_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new uninstall ");
             var result = parseResult.GetCompletions().ToArray();
@@ -72,7 +72,7 @@ public Task Uninstall_GetAllSuggestions()
         public Task Update_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new update ");
             var result = parseResult.GetCompletions().ToArray();
@@ -84,7 +84,7 @@ public Task Update_GetAllSuggestions()
         public Task List_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new list ");
             var result = parseResult.GetCompletions().ToArray();
@@ -96,7 +96,7 @@ public Task List_GetAllSuggestions()
         public Task Search_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new search ");
             var result = parseResult.GetCompletions().ToArray();
@@ -108,7 +108,7 @@ public Task Search_GetAllSuggestions()
         public Task Create_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new create ");
             var result = parseResult.GetCompletions().ToArray();
@@ -120,7 +120,7 @@ public Task Create_GetAllSuggestions()
         public Task TemplateCommand_GetAllSuggestions()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new console ");
             var 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 27b515ab1d..9b40af24fc 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
@@ -23,7 +23,7 @@ public partial class TabCompletionTests
         public void Instantiate_CanSuggestTemplateOption_StartsWith()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new console --framework net7.0 --l");
             var suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -39,7 +39,7 @@ public void Instantiate_CanSuggestTemplateOption_StartsWith()
         public void Instantiate_CanSuggestLanguages()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new console --language ");
             var suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -56,7 +56,7 @@ public void Instantiate_CanSuggestLanguages()
         public void Install_GetSuggestionsAfterInteractive()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new install --interactive ");
             var result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -69,7 +69,7 @@ public void Install_GetSuggestionsAfterInteractive()
         public void Install_GetSuggestionsAfterOptionWithoutArg()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new install --nuget-source ");
             var result = parseResult.GetCompletions().ToArray();
@@ -83,7 +83,7 @@ public void Install_GetSuggestionsAfterOptionWithoutArg()
         public void Install_GetSuggestionsAfterOptionWithArg()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new install --nuget-source me");
             var result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -96,7 +96,7 @@ public void Install_GetSuggestionsAfterOptionWithArg()
         public void Instantiate_CanSuggestTemplate_StartsWith()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            var myCommand = NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            var myCommand = NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse("new co");
             var suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -118,7 +118,7 @@ public void CanCompleteChoice_FromSingleTemplate()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --testChoice ");
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -144,7 +144,7 @@ public void CanCompleteChoice_FromSingleTemplate_StartsWith()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --testChoice v");
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -169,7 +169,7 @@ public void CanCompleteChoice_FromSingleTemplate_InTheMiddle()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --testChoice v --name test");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -198,7 +198,7 @@ public void CanCompleteChoice_FromMultipleTemplates()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --testChoice ");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -226,7 +226,7 @@ public void CanCompleteChoice_FromMultipleTemplates_StartsWith()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --testChoice v");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -256,7 +256,7 @@ public void CanCompleteParameters_FromMultipleTemplates()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo ");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -298,7 +298,7 @@ public void CanCompleteParameters_StartsWith_FromMultipleTemplates()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --t");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -342,7 +342,7 @@ public void CanCompleteParameters_StartsWith_AfterOption()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --foo val1 --bar val2 --t");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -384,7 +384,7 @@ public void CanCompleteLanguages(string optionName)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo {optionName} ");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -412,7 +412,7 @@ public void CanCompleteTypes()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo --type ");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs
index c8074d5382..9a261af803 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs
@@ -54,7 +54,7 @@ public Task CannotCreateCommandForInvalidParameter()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             InstantiateCommand instantiateCommand = InstantiateCommand.FromNewCommand(myCommand);
             var parseResult = instantiateCommand.Parse($" new foo");
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
index abe1213bfe..9728a3fdf9 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
@@ -18,7 +18,7 @@ public class UninstallTests
         public void Uninstall_NoArguments(string commandName)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new {commandName}");
             UninstallCommandArgs args = new UninstallCommandArgs((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -34,7 +34,7 @@ public void Uninstall_NoArguments(string commandName)
         public void Uninstall_WithArgument(string commandName)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new {commandName} source");
             UninstallCommandArgs args = new UninstallCommandArgs((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -51,7 +51,7 @@ public void Uninstall_WithArgument(string commandName)
         public void Uninstall_WithMultipleArgument(string command)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             UninstallCommandArgs args = new UninstallCommandArgs((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -72,7 +72,7 @@ public void Uninstall_WithMultipleArgument(string command)
         public void Uninstall_CanReturnParseError(string command, string expectedInvalidTokens)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             var errorMessages = parseResult.Errors.Select(error => error.Message);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
index 0f95b9cc5c..b6c2cf0f29 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
@@ -17,7 +17,7 @@ public class UpdateTests
         public void Update_CanParseAddSourceOption(string optionName)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new update {optionName} my-custom-source");
             UpdateCommandArgs args = new UpdateCommandArgs((UpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -33,7 +33,7 @@ public void Update_CanParseAddSourceOption(string optionName)
         public void Update_Error_WhenArguments(string commandName)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new {commandName} source");
 
@@ -47,7 +47,7 @@ public void Update_Error_WhenArguments(string commandName)
         public void Update_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new UpdateCommandArgs((UpdateCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -60,7 +60,7 @@ public void Update_CanParseAddSourceOption_MultipleEntries(string testCase)
         public void Update_CanParseInteractiveOption()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new update --interactive");
             UpdateCommandArgs args = new UpdateCommandArgs((UpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -79,7 +79,7 @@ public void Update_CanParseInteractiveOption()
         public void Update_CanParseCheckOnlyOption(string optionAlias)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new update {optionAlias}");
             UpdateCommandArgs args = new UpdateCommandArgs((UpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -96,7 +96,7 @@ public void Update_CanParseCheckOnlyOption(string optionAlias)
         public void Update_Legacy_CanParseCheckOnlyOption()
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse($"new --update-check");
             UpdateCommandArgs args = new UpdateCommandArgs((LegacyUpdateCheckCommand)parseResult.CommandResult.Command, parseResult);
@@ -116,7 +116,7 @@ public void Update_Legacy_CanParseCheckOnlyOption()
         public void Update_Legacy_CanParseAddSourceOption(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new UpdateCommandArgs((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -131,7 +131,7 @@ public void Update_Legacy_CanParseAddSourceOption(string testCase)
         public void Update_Legacy_CanParseInteractiveOption(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new UpdateCommandArgs((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -146,7 +146,7 @@ public void Update_Legacy_CanParseInteractiveOption(string testCase)
         public void Update_Legacy_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new UpdateCommandArgs((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -166,7 +166,7 @@ public void Update_Legacy_CanParseAddSourceOption_MultipleEntries(string testCas
         public void Update_CanReturnParseError(string command, string expectedInvalidTokens)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(command);
             var errorMessages = parseResult.Errors.Select(error => error.Message);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
index befde81abb..320c171410 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
@@ -517,7 +517,7 @@ public async Task TestGetTemplateResolutionResult_TemplateWithoutTypeShouldNotBe
         private static ListCommandArgs GetListCommandArgsFor(string commandInput)
         {
             ITemplateEngineHost host = TestHost.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(includeTestTemplates: false));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
 
             var parseResult = myCommand.Parse(commandInput);
             return new ListCommandArgs((ListCommand)parseResult.CommandResult.Command, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs
index 238a091234..5da3324e99 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs
@@ -77,7 +77,7 @@ public async Task CacheSearchNameMatchTest()
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search foo");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -122,7 +122,7 @@ public async Task CacheSearchCliSymbolNameFilterTest()
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search foo --framework netcoreapp2.0");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -164,7 +164,7 @@ public async Task CacheSearchCliSymbolNameMismatchFilterTest()
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search foo --tfm netcoreapp2.0");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -203,7 +203,7 @@ public async Task CacheSearchLanguageFilterTest()
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search bar --language F#");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -247,7 +247,7 @@ public async Task CacheSearchAuthorFilterTest(string commandTemplate, string com
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search {commandTemplate} --author {commandAuthor}");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -288,7 +288,7 @@ public async Task CacheSearchTypeFilterTest(string commandTemplate, string comma
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search {commandTemplate} --type {commandType}");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -330,7 +330,7 @@ public async Task CacheSearchPackageFilterTest(string commandTemplate, string co
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search {commandTemplate} --package {commandPackage}");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -377,7 +377,7 @@ public async Task CacheSearchTagFilterTest(string commandTemplate, string comman
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search {commandTemplate} --tag {commandTag}");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -419,7 +419,7 @@ public async Task CacheSearchLanguageMismatchFilterTest()
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search bar --language VB");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -457,7 +457,7 @@ public async Task CacheSkipInvalidTemplatesTest()
 
             engineEnvironmentSettings.Components.AddComponent(typeof(ITemplateSearchProviderFactory), new NuGetMetadataSearchProviderFactory());
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", engineEnvironmentSettings.Host, new TelemetryLogger(null, false), new NewCommandCallbacks());
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => engineEnvironmentSettings.Host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks());
             var parseResult = myCommand.Parse($"new search --unknown");
             SearchCommandArgs args = new SearchCommandArgs((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
diff --git a/test/Microsoft.TemplateEngine.EndToEndTestHarness/Program.cs b/test/Microsoft.TemplateEngine.EndToEndTestHarness/Program.cs
index 12cf19d4b8..a172c6e602 100644
--- a/test/Microsoft.TemplateEngine.EndToEndTestHarness/Program.cs
+++ b/test/Microsoft.TemplateEngine.EndToEndTestHarness/Program.cs
@@ -41,7 +41,7 @@ private static int Main(string[] args)
             ITemplateEngineHost host = CreateHost();
             host.VirtualizeDirectory(outputPath);
 
-            var command = NewCommandFactory.Create(CommandName, host, new TelemetryLogger(null), new NewCommandCallbacks());
+            var command = NewCommandFactory.Create(CommandName, _ => host, _ => new TelemetryLogger(null), new NewCommandCallbacks());
 
             int result = ParserFactory.CreateParser(command).Parse(passThroughArgs.ToArray()).Invoke();
 
diff --git a/test/dotnet-new3.UnitTests/Approvals/DotnetNewDebugOptions.CanShowConfigWithDebugShowConfig.approved.txt b/test/dotnet-new3.UnitTests/Approvals/DotnetNewDebugOptions.CanShowConfigWithDebugShowConfig.approved.txt
new file mode 100644
index 0000000000..bfa0f94985
--- /dev/null
+++ b/test/dotnet-new3.UnitTests/Approvals/DotnetNewDebugOptions.CanShowConfigWithDebugShowConfig.approved.txt
@@ -0,0 +1,30 @@
+Current configuration:
+ 
+Mount Point Factories                 Type                                                                        Assembly                                                                                            
+------------------------------------  --------------------------------------------------------------------------  ----------------------------------------------------------------------------------------------------
+94e92610-cf4c-4f6d-aeb6-9e42dde1899d  Microsoft.TemplateEngine.Edge.Mount.Archive.ZipFileMountPointFactory        Microsoft.TemplateEngine.Edge, Version=<version>, Culture=neutral, PublicKeyToken=<token>
+8c19221b-dea3-4250-86fe-2d4e189a11d2  Microsoft.TemplateEngine.Edge.Mount.FileSystem.FileSystemMountPointFactory  Microsoft.TemplateEngine.Edge, Version=<version>, Culture=neutral, PublicKeyToken=<token>
+
+
+Generators                            Type                                                                             Assembly                                                                                                                     
+------------------------------------  -------------------------------------------------------------------------------  -----------------------------------------------------------------------------------------------------------------------------
+0c434df7-e2cb-4dee-b216-d7c58c8eb4b3  Microsoft.TemplateEngine.Orchestrator.RunnableProjects.RunnableProjectGenerator  Microsoft.TemplateEngine.Orchestrator.RunnableProjects, Version=<version>, Culture=neutral, PublicKeyToken=<token>
+
+
+The 'dotnet new3' command creates a .NET project based on a template.
+
+Common templates are:
+Template Name  Short Name  Language    Tags          
+-------------  ----------  ----------  --------------
+Class Library  classlib    [C#],F#,VB  Common/Library
+Console App    console     [C#],F#,VB  Common/Console
+
+An example would be:
+   dotnet new3 console
+
+Display template options with:
+   dotnet new3 console -h
+Display all installed templates with:
+   dotnet new3 --list
+Display templates available on NuGet.org with:
+   dotnet new3 web --search
\ No newline at end of file
diff --git a/test/dotnet-new3.UnitTests/DotnetNew3Tests.cs b/test/dotnet-new3.UnitTests/DotnetNew3Tests.cs
new file mode 100644
index 0000000000..564e54765d
--- /dev/null
+++ b/test/dotnet-new3.UnitTests/DotnetNew3Tests.cs
@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+using ApprovalTests;
+using FluentAssertions;
+using Microsoft.NET.TestFramework.Assertions;
+using Microsoft.TemplateEngine.TestHelper;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Dotnet_new3.IntegrationTests
+{
+    public class DotnetNew3Tests
+    {
+        private readonly ITestOutputHelper _log;
+
+        public DotnetNew3Tests(ITestOutputHelper log)
+        {
+            _log = log;
+        }
+
+        [Fact]
+        public void CanDisableBuiltInTemplates_List()
+        {
+            string homeDir = TestUtils.CreateTemporaryFolder();
+            var commandResult = new DotnetNewCommand(_log, "list", "--debug:disable-sdk-templates")
+                .WithCustomHive()
+                .Execute();
+
+            commandResult
+                .Should()
+                .Pass()
+                .And.NotHaveStdOutContaining("console")
+                .And.HaveStdOutContaining("No templates installed.");
+        }
+
+        [Fact]
+        public void CanDisableBuiltInTemplates_Template()
+        {
+            string homeDir = TestUtils.CreateTemporaryFolder();
+            var commandResult = new DotnetNewCommand(_log, "console", "--debug:disable-sdk-templates")
+                .WithCustomHive()
+                .Execute();
+
+            commandResult
+                .Should()
+                .Fail()
+                .And.HaveStdErrContaining("No templates found matching: 'console'.");
+        }
+
+    }
+}
diff --git a/test/dotnet-new3.UnitTests/DotnetNewDebugOptions.cs b/test/dotnet-new3.UnitTests/DotnetNewDebugOptions.cs
index 293c42f657..d3f59b315d 100644
--- a/test/dotnet-new3.UnitTests/DotnetNewDebugOptions.cs
+++ b/test/dotnet-new3.UnitTests/DotnetNewDebugOptions.cs
@@ -3,6 +3,8 @@
 
 #nullable enable
 
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
 using FluentAssertions;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.TemplateEngine.TestHelper;
@@ -67,5 +69,55 @@ public void CanShowBasicInfoWithDebugRebuildCache()
             Assert.True(File.Exists(cacheFilePath));
             Assert.True(lastUpdateDate < File.GetLastWriteTimeUtc(cacheFilePath));
         }
+
+        [Fact]
+        public void CanShowConfigWithDebugShowConfig()
+        {
+            string home = TestUtils.CreateTemporaryFolder("Home");
+            var commandResult = new DotnetNewCommand(_log, "--debug:show-config")
+               .WithCustomHive(home)
+               .Execute();
+
+            commandResult.Should().ExitWith(0).And.NotHaveStdErr();
+            ApprovalTests.Approvals.Verify(commandResult.StdOut, (output) =>
+            {
+                //remove versions
+                var finalOutput = Regex.Replace(output, "Version=[A-Za-z0-9\\.]+", "Version=<version>");
+                //remove tokens
+                finalOutput = Regex.Replace(finalOutput, "PublicKeyToken=[A-Za-z0-9]+", "PublicKeyToken=<token>");
+                return finalOutput;
+            });
+        }
+
+        [Fact]
+        public void DoesNotCreateCacheWhenVirtualHiveIsUsed()
+        {
+            string home = TestUtils.CreateTemporaryFolder("Home");
+            var envVariable = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERPROFILE" : "HOME";
+
+            new DotnetNewCommand(_log, "--debug:ephemeral-hive")
+               .WithoutCustomHive()
+               .WithEnvironmentVariable(envVariable, home)
+               .Execute()
+               .Should().Pass().And.NotHaveStdErr();
+
+            Assert.Empty(new DirectoryInfo(home).EnumerateFiles());
+        }
+
+        [Fact]
+        public void DoesCreateCacheInDifferentLocationWhenCustomHiveIsUsed()
+        {
+            string home = TestUtils.CreateTemporaryFolder("Home");
+            new DotnetNewCommand(_log, "--debug:custom-hive", home)
+               .WithoutCustomHive()
+               .Execute()
+               .Should().Pass().And.NotHaveStdErr();
+
+            var createdCacheEntries = Directory.GetFileSystemEntries(home);
+
+            Assert.Equal(2, createdCacheEntries.Count());
+            Assert.Contains(Path.Combine(home, "packages"), createdCacheEntries);
+            Assert.True(File.Exists(Path.Combine(home, "dotnetcli-preview", "v2.0.0", "templatecache.json")));
+        }
     }
 }