From b331200121f55f93511aee22b7c86612aa0fb4e2 Mon Sep 17 00:00:00 2001
From: Morten Holt <mkh@contextand.com>
Date: Wed, 22 Apr 2026 22:22:04 +0200
Subject: [PATCH 1/6] Replace string-based root dispatch with typed
 ExecuteFromProfile   The root command previously re-dispatched sync items by
 reconstructing                                                               
                                                              string[] args
 and re-invoking System.CommandLine parsing, requiring                        
                                                                              
                          every option to be mirrored on the root command via
 ProfileOverrideProvider.

  Replace this with a typed dispatch contract: each sync command implements                                                                                                                          ExecuteFromProfile(SyncItem, ProfileExecutionContext, CancellationToken),                                                                                                                          which receives already-resolved values and calls the command's existing
  DI + sync logic directly. The root command now merges CLI overrides inline
  (one switch expression per sync item type) and calls ExecuteFromProfile
  on each sub-command until one claims the item.
                                                                                                                                                                                                     Remove ProfileOverrideProvider, XrmSyncSyncCommandBase, ArgumentOverrides,                                                                                                                         and all Execute*/ExecuteSubCommand/AddCommonArgs helpers from the root                                                                                                                             command. Root-level override options (--folder, --prefix, --operation,
  --client-id, --tenant-id, --file-extensions) are now first-class options
  on XrmSyncRootCommand rather than being advertised dynamically by
  sub-commands. Absorb sync-specific shared options and SyncCommandAction
  into XrmSyncCommandBase, flattening the command class hierarchy.
---
 XrmSync/Commands/ConfigCommand.cs           |   6 +-
 XrmSync/Commands/IXrmSyncCommand.cs         |  12 +-
 XrmSync/Commands/IdentityCommand.cs         |  87 ++++---
 XrmSync/Commands/PluginAnalyzeCommand.cs    |  58 ++---
 XrmSync/Commands/PluginSyncCommand.cs       |  50 ++--
 XrmSync/Commands/ProfileExecutionContext.cs |  14 +
 XrmSync/Commands/ProfileOverrideProvider.cs |  28 --
 XrmSync/Commands/WebresourceSyncCommand.cs  |  58 ++---
 XrmSync/Commands/XrmSyncCommandBase.cs      |  76 +++++-
 XrmSync/Commands/XrmSyncRootCommand.cs      | 269 +++++---------------
 XrmSync/Commands/XrmSyncSyncCommandBase.cs  |  66 -----
 11 files changed, 293 insertions(+), 431 deletions(-)
 create mode 100644 XrmSync/Commands/ProfileExecutionContext.cs
 delete mode 100644 XrmSync/Commands/ProfileOverrideProvider.cs
 delete mode 100644 XrmSync/Commands/XrmSyncSyncCommandBase.cs

diff --git a/XrmSync/Commands/ConfigCommand.cs b/XrmSync/Commands/ConfigCommand.cs
index f0659c6..b57bf05 100644
--- a/XrmSync/Commands/ConfigCommand.cs
+++ b/XrmSync/Commands/ConfigCommand.cs
@@ -1,4 +1,5 @@
 using System.CommandLine;
+using XrmSync.Model;
 
 namespace XrmSync.Commands;
 
@@ -14,7 +15,8 @@ public ConfigCommand() : base("config", "Configuration management commands")
 	public Command GetCommand() => this;
 
 	/// <summary>
-	/// Config command has no profile sync items to override.
+	/// Config command does not handle profile sync items.
 	/// </summary>
-	public ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution) => null;
+	public Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+		=> Task.FromResult<int?>(null);
 }
diff --git a/XrmSync/Commands/IXrmSyncCommand.cs b/XrmSync/Commands/IXrmSyncCommand.cs
index 62f2e5d..e23bf65 100644
--- a/XrmSync/Commands/IXrmSyncCommand.cs
+++ b/XrmSync/Commands/IXrmSyncCommand.cs
@@ -1,4 +1,5 @@
 using System.CommandLine;
+using XrmSync.Model;
 
 namespace XrmSync.Commands;
 
@@ -13,12 +14,9 @@ internal interface IXrmSyncCommand
 	Command GetCommand();
 
 	/// <summary>
-	/// Returns a <see cref="ProfileOverrideProvider"/> that advertises this command's unique
-	/// root-level override options and provides merge logic for applying CLI values into
-	/// profile sync items. The <paramref name="assembly"/> and <paramref name="solution"/>
-	/// options are shared, owned by the root command — use them in merge callbacks but do
-	/// not call Add() on them.
-	/// Returns null when the command has no profile overrides to advertise.
+	/// Executes this command using values already resolved from a profile sync item
+	/// and root-level execution context. Returns null when this command does not
+	/// handle the given sync item type; returns an exit code otherwise.
 	/// </summary>
-	ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution);
+	Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct);
 }
diff --git a/XrmSync/Commands/IdentityCommand.cs b/XrmSync/Commands/IdentityCommand.cs
index 8bfdf1f..2655e25 100644
--- a/XrmSync/Commands/IdentityCommand.cs
+++ b/XrmSync/Commands/IdentityCommand.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System.CommandLine;
 using XrmSync.Constants;
@@ -11,18 +12,13 @@
 
 namespace XrmSync.Commands;
 
-internal class IdentityCommand : XrmSyncSyncCommandBase
+internal class IdentityCommand : XrmSyncCommandBase
 {
 	private readonly Option<IdentityOperation?> operation;
 	private readonly Option<string> assemblyFile;
 	private readonly Option<string> clientId;
 	private readonly Option<string> tenantId;
 
-	// Root-level override options (advertised to XrmSyncRootCommand via GetProfileOverrides)
-	private readonly Option<IdentityOperation?> rootOperation = CliOptions.ManagedIdentity.Operation.CreateOption<IdentityOperation?>();
-	private readonly Option<string?> rootClientId = CliOptions.ManagedIdentity.ClientId.CreateOption<string?>();
-	private readonly Option<string?> rootTenantId = CliOptions.ManagedIdentity.TenantId.CreateOption<string?>();
-
 	public IdentityCommand() : base("identity", "Manage the managed identity linked to a plugin assembly")
 	{
 		operation = CliOptions.ManagedIdentity.Operation.CreateOption<IdentityOperation?>();
@@ -36,32 +32,33 @@ public IdentityCommand() : base("identity", "Manage the managed identity linked
 		Add(tenantId);
 
 		AddSharedOptions();
-		AddSyncSharedOptions();
+		AddSyncOptions();
 
 		SetAction(ExecuteAsync);
 	}
 
-	/// <summary>
-	/// Advertises --client-id and --tenant-id as root-level overrides.
-	/// The shared assembly option is used in the merge callback but owned by the root command.
-	/// </summary>
-	public override ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution) => new(
-		options: [rootOperation, rootClientId, rootTenantId],
-		mergeSyncItem: (item, parseResult) =>
+	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	{
+		if (syncItem is not IdentitySyncItem identity) return null;
+
+		if (identity.Operation == null)
 		{
-			if (item is not IdentitySyncItem identity) return null;
-			var operationValue = parseResult.GetValue(rootOperation);
-			var clientIdValue = parseResult.GetValue(rootClientId);
-			var tenantIdValue = parseResult.GetValue(rootTenantId);
-			var assemblyValue = parseResult.GetValue(assembly);
-			return identity with
-			{
-				Operation = operationValue ?? identity.Operation,
-				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyValue) ? assemblyValue : identity.AssemblyPath,
-				ClientId = !string.IsNullOrWhiteSpace(clientIdValue) ? clientIdValue : identity.ClientId,
-				TenantId = !string.IsNullOrWhiteSpace(tenantIdValue) ? tenantIdValue : identity.TenantId
-			};
-		});
+			Console.Error.WriteLine("Identity sync item has no operation configured and none was supplied via --operation.");
+			return E_ERROR;
+		}
+
+		return await RunCore(
+			identity.Operation.Value,
+			identity.AssemblyPath,
+			ctx.SolutionName,
+			identity.ClientId,
+			identity.TenantId,
+			ctx.DryRun,
+			ctx.CiMode,
+			ctx.LogLevel,
+			ctx.ProfileName,
+			ct);
+	}
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
@@ -134,10 +131,38 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		if (errors.Count > 0)
 			return ValidationError($"identity --operation {finalOperation?.ToString() ?? "<none>"}", errors);
 
-		// Build service provider with validated options
+		return await RunCore(finalOperation!.Value, finalAssemblyPath, finalSolutionName, finalClientId, finalTenantId, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
+	}
+
+	private async Task<int> RunCore(
+		IdentityOperation operation,
+		string assemblyPath,
+		string solutionName,
+		string? clientId,
+		string? tenantId,
+		bool? dryRun,
+		bool? ciMode,
+		LogLevel? logLevel,
+		string? profileName,
+		CancellationToken ct)
+	{
+		// Validate resolved values (when called from ExecuteAsync, validation already done above)
+		var errors = new List<string>();
+		errors.AddRange(XrmSyncConfigurationValidator.ValidateAssemblyPath(assemblyPath));
+		errors.AddRange(XrmSyncConfigurationValidator.ValidateSolutionName(solutionName));
+
+		if (operation == IdentityOperation.Ensure)
+		{
+			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(clientId ?? string.Empty, "Client ID"));
+			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(tenantId ?? string.Empty, "Tenant ID"));
+		}
+
+		if (errors.Count > 0)
+			return ValidationError($"identity --operation {operation}", errors);
+
 		var serviceProvider = new ServiceCollection()
 			.AddIdentityService()
-			.AddXrmSyncConfiguration(sharedOptions)
+			.AddXrmSyncConfiguration(new SharedOptions(profileName))
 			.AddOptions(
 				baseOptions => baseOptions with
 				{
@@ -145,7 +170,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 					CiMode = ciMode ?? baseOptions.CiMode,
 					DryRun = dryRun ?? baseOptions.DryRun
 				})
-			.AddSingleton(MSOptions.Create(new IdentityCommandOptions(finalOperation!.Value, finalAssemblyPath, finalSolutionName, finalClientId, finalTenantId)))
+			.AddSingleton(MSOptions.Create(new IdentityCommandOptions(operation, assemblyPath, solutionName, clientId, tenantId)))
 			.AddSingleton(sp =>
 			{
 				var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
@@ -154,7 +179,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			.AddLogger()
 			.BuildServiceProvider();
 
-		return await RunAction(serviceProvider, ConfigurationScope.None, CommandAction, cancellationToken)
+		return await RunAction(serviceProvider, ConfigurationScope.None, SyncCommandAction, ct)
 			? E_OK
 			: E_ERROR;
 	}
diff --git a/XrmSync/Commands/PluginAnalyzeCommand.cs b/XrmSync/Commands/PluginAnalyzeCommand.cs
index 5c4bcc4..cd38501 100644
--- a/XrmSync/Commands/PluginAnalyzeCommand.cs
+++ b/XrmSync/Commands/PluginAnalyzeCommand.cs
@@ -15,14 +15,10 @@ namespace XrmSync.Commands;
 
 internal class PluginAnalyzeCommand : XrmSyncCommandBase
 {
-
 	private readonly Option<string> assemblyFile;
 	private readonly Option<string> prefix;
 	private readonly Option<bool> prettyPrint;
 
-	// Root-level override options (advertised to XrmSyncRootCommand via GetProfileOverrides)
-	private readonly Option<string?> rootPrefix = CliOptions.Analysis.Prefix.CreateOption<string?>();
-
 	public PluginAnalyzeCommand() : base("analyze", "Analyze a plugin assembly and output info as JSON")
 	{
 		assemblyFile = CliOptions.Assembly.CreateOption<string>();
@@ -37,29 +33,17 @@ public PluginAnalyzeCommand() : base("analyze", "Analyze a plugin assembly and o
 		SetAction(ExecuteAsync);
 	}
 
-	/// <summary>
-	/// Advertises --prefix as a root-level override.
-	/// The shared assembly option is used in the merge callback but owned by the root command.
-	/// </summary>
-	public override ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution) => new(
-		options: [rootPrefix],
-		mergeSyncItem: (item, parseResult) =>
-		{
-			if (item is not PluginAnalysisSyncItem analysis) return null;
-			var assemblyValue = parseResult.GetValue(assembly);
-			var prefixValue = parseResult.GetValue(rootPrefix);
-			return analysis with
-			{
-				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyValue) ? assemblyValue : analysis.AssemblyPath,
-				PublisherPrefix = !string.IsNullOrWhiteSpace(prefixValue) ? prefixValue : analysis.PublisherPrefix
-			};
-		});
+	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	{
+		if (syncItem is not PluginAnalysisSyncItem analysis) return null;
+		return await RunCore(analysis.AssemblyPath, analysis.PublisherPrefix, analysis.PrettyPrint, ctx.ProfileName, ct);
+	}
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
 		var assemblyPath = parseResult.GetValue(assemblyFile);
 		var publisherPrefix = parseResult.GetValue(prefix);
-		var prettyPrint = parseResult.GetValue(this.prettyPrint);
+		var prettyPrintValue = parseResult.GetValue(this.prettyPrint);
 		var sharedOptions = GetSharedOptionValues(parseResult);
 
 		// Resolve final options eagerly (CLI + profile merge)
@@ -72,7 +56,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			// Standalone mode: all required values supplied via CLI
 			finalAssemblyPath = assemblyPath;
 			finalPublisherPrefix = publisherPrefix;
-			finalPrettyPrint = prettyPrint;
+			finalPrettyPrint = prettyPrintValue;
 		}
 		else
 		{
@@ -92,30 +76,38 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 
 			finalAssemblyPath = !string.IsNullOrWhiteSpace(assemblyPath) ? assemblyPath : (pluginAnalysisItem?.AssemblyPath ?? string.Empty);
 			finalPublisherPrefix = !string.IsNullOrWhiteSpace(publisherPrefix) ? publisherPrefix : (pluginAnalysisItem?.PublisherPrefix ?? string.Empty);
-			finalPrettyPrint = prettyPrint || (pluginAnalysisItem?.PrettyPrint ?? false);
+			finalPrettyPrint = prettyPrintValue || (pluginAnalysisItem?.PrettyPrint ?? false);
 		}
 
-		// Validate resolved values
-		var errors = XrmSyncConfigurationValidator.ValidateAssemblyPath(finalAssemblyPath)
-			.Concat(XrmSyncConfigurationValidator.ValidatePublisherPrefix(finalPublisherPrefix))
+		return await RunCore(finalAssemblyPath, finalPublisherPrefix, finalPrettyPrint, sharedOptions.ProfileName, cancellationToken);
+	}
+
+	private async Task<int> RunCore(
+		string assemblyPath,
+		string publisherPrefix,
+		bool prettyPrintValue,
+		string? profileName,
+		CancellationToken ct)
+	{
+		var errors = XrmSyncConfigurationValidator.ValidateAssemblyPath(assemblyPath)
+			.Concat(XrmSyncConfigurationValidator.ValidatePublisherPrefix(publisherPrefix))
 			.ToList();
 		if (errors.Count > 0)
 			return ValidationError("analyze", errors);
 
-		// Build service provider with validated options
 		var serviceProvider = GetAnalyzerServices()
-			.AddXrmSyncConfiguration(sharedOptions)
+			.AddXrmSyncConfiguration(new SharedOptions(profileName))
 			.AddOptions(baseOptions => baseOptions)
-			.AddSingleton(MSOptions.Create(new PluginAnalysisCommandOptions(finalAssemblyPath, finalPublisherPrefix, finalPrettyPrint)))
+			.AddSingleton(MSOptions.Create(new PluginAnalysisCommandOptions(assemblyPath, publisherPrefix, prettyPrintValue)))
 			.AddLogger()
 			.BuildServiceProvider();
 
-		return await RunAction(serviceProvider, ConfigurationScope.None, CommandAction, cancellationToken)
+		return await RunAction(serviceProvider, ConfigurationScope.None, AnalyzeCommandAction, ct)
 			? E_OK
 			: E_ERROR;
 	}
 
-	private static async Task<bool> CommandAction(IServiceProvider serviceProvider, CancellationToken cancellationToken)
+	private static async Task<bool> AnalyzeCommandAction(IServiceProvider serviceProvider, CancellationToken cancellationToken)
 	{
 		return await Task.Run(() =>
 		{
@@ -145,9 +137,7 @@ private static async Task<bool> CommandAction(IServiceProvider serviceProvider,
 	private static IServiceCollection GetAnalyzerServices(IServiceCollection? services = null)
 	{
 		services ??= new ServiceCollection();
-
 		services.AddAssemblyAnalyzer();
-
 		return services;
 	}
 }
diff --git a/XrmSync/Commands/PluginSyncCommand.cs b/XrmSync/Commands/PluginSyncCommand.cs
index aec7fca..7ca03d2 100644
--- a/XrmSync/Commands/PluginSyncCommand.cs
+++ b/XrmSync/Commands/PluginSyncCommand.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System.CommandLine;
 using XrmSync.Constants;
@@ -10,7 +11,7 @@
 
 namespace XrmSync.Commands;
 
-internal class PluginSyncCommand : XrmSyncSyncCommandBase
+internal class PluginSyncCommand : XrmSyncCommandBase
 {
 	private readonly Option<string> assemblyFile;
 
@@ -21,25 +22,16 @@ public PluginSyncCommand() : base("plugins", "Synchronize plugins in a plugin as
 		Add(assemblyFile);
 
 		AddSharedOptions();
-		AddSyncSharedOptions();
+		AddSyncOptions();
 
 		SetAction(ExecuteAsync);
 	}
 
-	/// <summary>
-	/// Plugin sync has no unique override options — it only uses the shared assembly + solution options.
-	/// </summary>
-	public override ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution) => new(
-		options: [],
-		mergeSyncItem: (item, parseResult) =>
-		{
-			if (item is not PluginSyncItem plugin) return null;
-			var assemblyValue = parseResult.GetValue(assembly);
-			return plugin with
-			{
-				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyValue) ? assemblyValue : plugin.AssemblyPath
-			};
-		});
+	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	{
+		if (syncItem is not PluginSyncItem plugin) return null;
+		return await RunCore(plugin.AssemblyPath, ctx.SolutionName, ctx.DryRun, ctx.CiMode, ctx.LogLevel, ctx.ProfileName, ct);
+	}
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
@@ -77,16 +69,26 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			finalSolutionName = !string.IsNullOrWhiteSpace(solutionName) ? solutionName : profile.SolutionName;
 		}
 
-		// Validate resolved values
-		var errors = XrmSyncConfigurationValidator.ValidateAssemblyPath(finalAssemblyPath)
-			.Concat(XrmSyncConfigurationValidator.ValidateSolutionName(finalSolutionName))
+		return await RunCore(finalAssemblyPath, finalSolutionName, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
+	}
+
+	private async Task<int> RunCore(
+		string assemblyPath,
+		string solutionName,
+		bool? dryRun,
+		bool? ciMode,
+		LogLevel? logLevel,
+		string? profileName,
+		CancellationToken ct)
+	{
+		var errors = XrmSyncConfigurationValidator.ValidateAssemblyPath(assemblyPath)
+			.Concat(XrmSyncConfigurationValidator.ValidateSolutionName(solutionName))
 			.ToList();
 		if (errors.Count > 0)
 			return ValidationError("plugins", errors);
 
-		// Build service provider with validated options
 		var serviceProvider = GetPluginSyncServices()
-			.AddXrmSyncConfiguration(sharedOptions)
+			.AddXrmSyncConfiguration(new SharedOptions(profileName))
 			.AddOptions(
 				baseOptions => baseOptions with
 				{
@@ -94,7 +96,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 					CiMode = ciMode ?? baseOptions.CiMode,
 					DryRun = dryRun ?? baseOptions.DryRun
 				})
-			.AddSingleton(MSOptions.Create(new PluginSyncCommandOptions(finalAssemblyPath, finalSolutionName)))
+			.AddSingleton(MSOptions.Create(new PluginSyncCommandOptions(assemblyPath, solutionName)))
 			.AddSingleton(sp =>
 			{
 				var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
@@ -103,7 +105,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			.AddLogger()
 			.BuildServiceProvider();
 
-		return await RunAction(serviceProvider, ConfigurationScope.None, CommandAction, cancellationToken)
+		return await RunAction(serviceProvider, ConfigurationScope.None, SyncCommandAction, ct)
 			? E_OK
 			: E_ERROR;
 	}
@@ -111,9 +113,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 	private static IServiceCollection GetPluginSyncServices(IServiceCollection? services = null)
 	{
 		services ??= new ServiceCollection();
-
 		services.AddPluginSyncService();
-
 		return services;
 	}
 }
diff --git a/XrmSync/Commands/ProfileExecutionContext.cs b/XrmSync/Commands/ProfileExecutionContext.cs
new file mode 100644
index 0000000..c7d7f24
--- /dev/null
+++ b/XrmSync/Commands/ProfileExecutionContext.cs
@@ -0,0 +1,14 @@
+using Microsoft.Extensions.Logging;
+
+namespace XrmSync.Commands;
+
+/// <summary>
+/// Carries the already-resolved execution values the root command passes to sub-commands
+/// when dispatching profile sync items.
+/// </summary>
+internal record ProfileExecutionContext(
+	string SolutionName,
+	bool DryRun,
+	bool CiMode,
+	LogLevel LogLevel,
+	string? ProfileName);
diff --git a/XrmSync/Commands/ProfileOverrideProvider.cs b/XrmSync/Commands/ProfileOverrideProvider.cs
deleted file mode 100644
index b528dd9..0000000
--- a/XrmSync/Commands/ProfileOverrideProvider.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System.CommandLine;
-using System.CommandLine.Parsing;
-using XrmSync.Model;
-
-namespace XrmSync.Commands;
-
-/// <summary>
-/// Advertises a command's unique root-level override options and provides merge logic
-/// for applying CLI override values into profile sync items.
-/// </summary>
-internal sealed class ProfileOverrideProvider(
-	IReadOnlyList<Option> options,
-	Func<SyncItem, ParseResult, SyncItem?> mergeSyncItem)
-{
-	/// <summary>
-	/// Options unique to this command that should be added to the root command.
-	/// Shared options (assembly, solution) are owned by the root command, not listed here.
-	/// </summary>
-	public IReadOnlyList<Option> Options { get; } = options;
-
-	/// <summary>
-	/// Merges CLI override values into a sync item.
-	/// Returns the merged item if this provider handles the given sync item type,
-	/// or null if the item type is not handled by this provider.
-	/// </summary>
-	public SyncItem? MergeSyncItem(SyncItem item, ParseResult parseResult)
-		=> mergeSyncItem(item, parseResult);
-}
diff --git a/XrmSync/Commands/WebresourceSyncCommand.cs b/XrmSync/Commands/WebresourceSyncCommand.cs
index 137f514..ec713e9 100644
--- a/XrmSync/Commands/WebresourceSyncCommand.cs
+++ b/XrmSync/Commands/WebresourceSyncCommand.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System.CommandLine;
 using XrmSync.Constants;
@@ -10,15 +11,11 @@
 
 namespace XrmSync.Commands
 {
-	internal class WebresourceSyncCommand : XrmSyncSyncCommandBase
+	internal class WebresourceSyncCommand : XrmSyncCommandBase
 	{
 		private readonly Option<string> webresourceRoot;
 		private readonly Option<string[]> fileExtensions;
 
-		// Root-level override options (advertised to XrmSyncRootCommand via GetProfileOverrides)
-		private readonly Option<string?> rootFolder = CliOptions.Webresource.CreateOption<string?>();
-		private readonly Option<string[]?> rootFileExtensions = CliOptions.FileExtensions.CreateOption<string[]?>();
-
 		public WebresourceSyncCommand() : base("webresources", "Synchronize webresources from a local folder with Dataverse")
 		{
 			webresourceRoot = CliOptions.Webresource.CreateOption<string>();
@@ -28,28 +25,16 @@ public WebresourceSyncCommand() : base("webresources", "Synchronize webresources
 			Add(fileExtensions);
 
 			AddSharedOptions();
-			AddSyncSharedOptions();
+			AddSyncOptions();
 
 			SetAction(ExecuteAsync);
 		}
 
-		/// <summary>
-		/// Advertises --folder and --file-extensions as root-level overrides.
-		/// The shared solution option is used in the merge callback but owned by the root command.
-		/// </summary>
-		public override ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution) => new(
-			options: [rootFolder, rootFileExtensions],
-			mergeSyncItem: (item, parseResult) =>
-			{
-				if (item is not WebresourceSyncItem webresource) return null;
-				var folderValue = parseResult.GetValue(rootFolder);
-				var extensions = parseResult.GetValue(rootFileExtensions);
-				return webresource with
-				{
-					FolderPath = !string.IsNullOrWhiteSpace(folderValue) ? folderValue : webresource.FolderPath,
-					FileExtensions = extensions is { Length: > 0 } ? extensions.ToList() : webresource.FileExtensions
-				};
-			});
+		public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+		{
+			if (syncItem is not WebresourceSyncItem webresource) return null;
+			return await RunCore(webresource.FolderPath, ctx.SolutionName, webresource.FileExtensions, ctx.DryRun, ctx.CiMode, ctx.LogLevel, ctx.ProfileName, ct);
+		}
 
 		private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 		{
@@ -91,16 +76,27 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 				finalExtensions = extensionsValue is { Length: > 0 } ? extensionsValue.ToList() : webresourceSyncItem?.FileExtensions;
 			}
 
-			// Validate resolved values
-			var errors = XrmSyncConfigurationValidator.ValidateFolderPath(finalFolderPath)
-				.Concat(XrmSyncConfigurationValidator.ValidateSolutionName(finalSolutionName))
+			return await RunCore(finalFolderPath, finalSolutionName, finalExtensions, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
+		}
+
+		private async Task<int> RunCore(
+			string folderPath,
+			string solutionName,
+			List<string>? fileExtensionsList,
+			bool? dryRun,
+			bool? ciMode,
+			LogLevel? logLevel,
+			string? profileName,
+			CancellationToken ct)
+		{
+			var errors = XrmSyncConfigurationValidator.ValidateFolderPath(folderPath)
+				.Concat(XrmSyncConfigurationValidator.ValidateSolutionName(solutionName))
 				.ToList();
 			if (errors.Count > 0)
 				return ValidationError("webresources", errors);
 
-			// Build service provider with validated options
 			var serviceProvider = GetWebresourceSyncServices()
-				.AddXrmSyncConfiguration(sharedOptions)
+				.AddXrmSyncConfiguration(new SharedOptions(profileName))
 				.AddOptions(
 					options => options with
 					{
@@ -109,7 +105,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 						DryRun = dryRun ?? options.DryRun
 					}
 				)
-				.AddSingleton(MSOptions.Create(new WebresourceSyncCommandOptions(finalFolderPath, finalSolutionName, finalExtensions)))
+				.AddSingleton(MSOptions.Create(new WebresourceSyncCommandOptions(folderPath, solutionName, fileExtensionsList)))
 				.AddSingleton(sp =>
 				{
 					var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
@@ -118,7 +114,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 				.AddLogger()
 				.BuildServiceProvider();
 
-			return await RunAction(serviceProvider, ConfigurationScope.None, CommandAction, cancellationToken)
+			return await RunAction(serviceProvider, ConfigurationScope.None, SyncCommandAction, ct)
 				? E_OK
 				: E_ERROR;
 		}
@@ -126,9 +122,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		private static IServiceCollection GetWebresourceSyncServices(IServiceCollection? services = null)
 		{
 			services ??= new ServiceCollection();
-
 			services.AddWebresourceSyncAction();
-
 			return services;
 		}
 	}
diff --git a/XrmSync/Commands/XrmSyncCommandBase.cs b/XrmSync/Commands/XrmSyncCommandBase.cs
index 409abb1..9c52205 100644
--- a/XrmSync/Commands/XrmSyncCommandBase.cs
+++ b/XrmSync/Commands/XrmSyncCommandBase.cs
@@ -6,7 +6,7 @@
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
 using XrmSync.Options;
-using MSOptions = Microsoft.Extensions.Options.Options;
+using XrmSync.SyncService;
 
 namespace XrmSync.Commands;
 
@@ -21,34 +21,67 @@ internal abstract class XrmSyncCommandBase(string name, string description) : Co
 	// Shared options available to all commands
 	protected Option<string?> ProfileNameOption { get; private set; } = null!;
 
+	// Sync-specific shared options (populated by AddSyncOptions)
+	protected Option<string> SolutionName { get; private set; } = null!;
+	protected Option<bool?> DryRun { get; private set; } = null!;
+	protected Option<LogLevel?> LogLevel { get; private set; } = null!;
+	protected Option<bool?> CiMode { get; private set; } = null!;
+
 	public Command GetCommand() => this;
 
 	/// <summary>
-	/// Default implementation: this command advertises no profile overrides.
-	/// Override in subclasses to expose sync-item-specific CLI options on the root command.
+	/// Default implementation: this command does not handle profile sync items.
+	/// Override in sync sub-commands to handle a specific SyncItem subtype.
 	/// </summary>
-	public virtual ProfileOverrideProvider? GetProfileOverrides(Option<string?> assembly, Option<string?> solution) => null;
+	public virtual Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+		=> Task.FromResult<int?>(null);
 
 	/// <summary>
-	/// Adds shared options to the command (profile)
+	/// Adds the profile option to the command
 	/// </summary>
 	protected void AddSharedOptions()
 	{
 		ProfileNameOption = CliOptions.Config.Profile.CreateOption<string?>();
-
 		Add(ProfileNameOption);
 	}
 
+	/// <summary>
+	/// Adds sync-specific shared options: --solution, --dry-run, --log-level, --ci-mode
+	/// </summary>
+	protected void AddSyncOptions()
+	{
+		SolutionName = CliOptions.Solution.CreateOption<string>();
+		DryRun = CliOptions.Execution.DryRun.CreateOption<bool?>();
+		LogLevel = CliOptions.Logging.LogLevel.CreateOption<LogLevel?>();
+		CiMode = CliOptions.Logging.CiMode.CreateOption<bool?>();
+
+		Add(SolutionName);
+		Add(DryRun);
+		Add(LogLevel);
+		Add(CiMode);
+	}
+
 	/// <summary>
 	/// Gets the shared option values from a parse result
 	/// </summary>
 	protected SharedOptions GetSharedOptionValues(ParseResult parseResult)
 	{
 		var profileName = parseResult.GetValue(ProfileNameOption);
-
 		return new(profileName);
 	}
 
+	/// <summary>
+	/// Gets the sync-specific shared option values from a parse result
+	/// </summary>
+	protected (string? SolutionName, bool? DryRun, LogLevel? LogLevel, bool? CIMode) GetSyncSharedOptionValues(ParseResult parseResult)
+	{
+		var solutionName = parseResult.GetValue(SolutionName);
+		var dryRun = parseResult.GetValue(DryRun);
+		var logLevel = parseResult.GetValue(LogLevel);
+		var ciMode = parseResult.GetValue(CiMode);
+		return (solutionName, dryRun, logLevel, ciMode);
+	}
+
 	/// <summary>
 	/// Resolves the profile by name, throwing a consistent error if not found
 	/// </summary>
@@ -124,4 +157,33 @@ protected static async Task<bool> RunAction(
 
 		return await action(serviceProvider, cancellationToken);
 	}
+
+	/// <summary>
+	/// Standard action for sync commands: runs ISyncService.Sync and handles common exceptions.
+	/// </summary>
+	protected static async Task<bool> SyncCommandAction(IServiceProvider serviceProvider, CancellationToken cancellationToken)
+	{
+		var logger = serviceProvider.GetRequiredService<ILogger<XrmSyncCommandBase>>();
+		try
+		{
+			var syncService = serviceProvider.GetRequiredService<ISyncService>();
+			await syncService.Sync(cancellationToken);
+			return true;
+		}
+		catch (OptionsValidationException ex)
+		{
+			logger.LogCritical("Configuration validation failed:{nl}{message}", Environment.NewLine, ex.Message);
+			return false;
+		}
+		catch (XrmSyncException ex)
+		{
+			logger.LogError("Error during synchronization: {message}", ex.Message);
+			return false;
+		}
+		catch (Exception ex)
+		{
+			logger.LogCritical(ex, "An unexpected error occurred during synchronization: {message}", ex.Message);
+			return false;
+		}
+	}
 }
diff --git a/XrmSync/Commands/XrmSyncRootCommand.cs b/XrmSync/Commands/XrmSyncRootCommand.cs
index 4aaf8df..0e361bb 100644
--- a/XrmSync/Commands/XrmSyncRootCommand.cs
+++ b/XrmSync/Commands/XrmSyncRootCommand.cs
@@ -5,19 +5,10 @@
 using XrmSync.Extensions;
 using XrmSync.Model;
 using XrmSync.Options;
-using XrmSync.SyncService;
 using MSOptions = Microsoft.Extensions.Options.Options;
 
 namespace XrmSync.Commands;
 
-/// <summary>
-/// DTO for argument overrides when building sub-command arguments
-/// </summary>
-/// <param name="DryRun">Override for dry run mode</param>
-/// <param name="CiMode">Override for CI mode</param>
-/// <param name="LogLevel">Override for log level</param>
-internal record ArgumentOverrides(bool DryRun, bool CiMode, LogLevel? LogLevel);
-
 /// <summary>
 /// Root command handler that executes all sync items in a profile
 /// </summary>
@@ -29,39 +20,41 @@ internal class XrmSyncRootCommand : XrmSyncCommandBase
 	private readonly Option<LogLevel?> logLevel;
 	private readonly Option<string?> assembly;
 	private readonly Option<string?> solution;
-	private readonly IReadOnlyList<ProfileOverrideProvider> profileOverrideProviders;
+	private readonly Option<string?> folder;
+	private readonly Option<string[]?> fileExtensions;
+	private readonly Option<string?> prefix;
+	private readonly Option<IdentityOperation?> operation;
+	private readonly Option<string?> clientId;
+	private readonly Option<string?> tenantId;
 
 	public XrmSyncRootCommand(List<IXrmSyncCommand> subCommands)
 		: base("xrmsync", "XrmSync - Synchronize your Dataverse plugins and webresources")
 	{
 		this.subCommands = subCommands;
 
-		// Add override options
 		dryRun = CliOptions.Execution.DryRun.CreateOption<bool?>();
 		ciMode = CliOptions.Logging.CiMode.CreateOption<bool?>();
 		logLevel = CliOptions.Logging.LogLevel.CreateOption<LogLevel?>();
-
-		// Shared options owned by root command, passed into command override providers
 		assembly = CliOptions.Assembly.CreateOption<string?>();
 		solution = CliOptions.Solution.CreateOption<string?>();
+		folder = CliOptions.Webresource.CreateOption<string?>();
+		fileExtensions = CliOptions.FileExtensions.CreateOption<string[]?>();
+		prefix = CliOptions.Analysis.Prefix.CreateOption<string?>();
+		operation = CliOptions.ManagedIdentity.Operation.CreateOption<IdentityOperation?>();
+		clientId = CliOptions.ManagedIdentity.ClientId.CreateOption<string?>();
+		tenantId = CliOptions.ManagedIdentity.TenantId.CreateOption<string?>();
 
 		Add(dryRun);
 		Add(ciMode);
 		Add(logLevel);
 		Add(assembly);
 		Add(solution);
-
-		// Discover and register override options from sub-commands
-		var providers = new List<ProfileOverrideProvider>();
-		foreach (var cmd in subCommands)
-		{
-			var provider = cmd.GetProfileOverrides(assembly, solution);
-			if (provider == null) continue;
-			providers.Add(provider);
-			foreach (var option in provider.Options)
-				Add(option);
-		}
-		profileOverrideProviders = providers.AsReadOnly();
+		Add(folder);
+		Add(fileExtensions);
+		Add(prefix);
+		Add(operation);
+		Add(clientId);
+		Add(tenantId);
 
 		AddSharedOptions();
 		SetAction(ExecuteAsync);
@@ -71,12 +64,18 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 	{
 		var sharedOptions = GetSharedOptionValues(parseResult);
 
-		// Parse override values from CLI
 		var dryRunOverride = parseResult.GetValue(dryRun);
 		var ciModeOverride = parseResult.GetValue(ciMode);
 		var logLevelOverride = parseResult.GetValue(logLevel);
+		var assemblyOverride = parseResult.GetValue(assembly);
+		var solutionOverride = parseResult.GetValue(solution);
+		var folderOverride = parseResult.GetValue(folder);
+		var fileExtensionsOverride = parseResult.GetValue(fileExtensions);
+		var prefixOverride = parseResult.GetValue(prefix);
+		var operationOverride = parseResult.GetValue(operation);
+		var clientIdOverride = parseResult.GetValue(clientId);
+		var tenantIdOverride = parseResult.GetValue(tenantId);
 
-		// Load raw profile and config from appsettings
 		ProfileConfiguration? rawProfile;
 		XrmSyncConfiguration rawConfig;
 		try
@@ -95,23 +94,36 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			return E_ERROR;
 		}
 
-		// Merge CLI overrides into each sync item via advertised providers
-		var mergedSync = rawProfile.Sync.Select(item =>
+		// Merge CLI overrides into each sync item
+		var mergedSync = rawProfile.Sync.Select<SyncItem, SyncItem>(item => item switch
 		{
-			foreach (var provider in profileOverrideProviders)
+			PluginSyncItem plugin => plugin with
 			{
-				var merged = provider.MergeSyncItem(item, parseResult);
-				if (merged != null) return merged;
-			}
-			return item;
+				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyOverride) ? assemblyOverride : plugin.AssemblyPath
+			},
+			PluginAnalysisSyncItem analysis => analysis with
+			{
+				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyOverride) ? assemblyOverride : analysis.AssemblyPath,
+				PublisherPrefix = !string.IsNullOrWhiteSpace(prefixOverride) ? prefixOverride : analysis.PublisherPrefix
+			},
+			WebresourceSyncItem webresource => webresource with
+			{
+				FolderPath = !string.IsNullOrWhiteSpace(folderOverride) ? folderOverride : webresource.FolderPath,
+				FileExtensions = fileExtensionsOverride is { Length: > 0 } ? fileExtensionsOverride.ToList() : webresource.FileExtensions
+			},
+			IdentitySyncItem identity => identity with
+			{
+				Operation = operationOverride ?? identity.Operation,
+				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyOverride) ? assemblyOverride : identity.AssemblyPath,
+				ClientId = !string.IsNullOrWhiteSpace(clientIdOverride) ? clientIdOverride : identity.ClientId,
+				TenantId = !string.IsNullOrWhiteSpace(tenantIdOverride) ? tenantIdOverride : identity.TenantId
+			},
+			_ => item
 		}).ToList();
 
-		// Apply solution override at profile level
-		var solutionOverride = parseResult.GetValue(solution);
 		var mergedSolutionName = !string.IsNullOrWhiteSpace(solutionOverride) ? solutionOverride : rawProfile.SolutionName;
 		var mergedProfile = rawProfile with { SolutionName = mergedSolutionName, Sync = mergedSync };
 
-		// Build merged config: profile with CLI-overridden sync items + execution mode overrides
 		var mergedConfig = rawConfig with
 		{
 			DryRun = dryRunOverride ?? rawConfig.DryRun,
@@ -122,7 +134,6 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 				.ToList()
 		};
 
-		// Build DI service provider with merged config
 		var serviceProvider = new ServiceCollection()
 			.AddSingleton(MSOptions.Create(mergedConfig))
 			.AddSingleton(MSOptions.Create(sharedOptions))
@@ -146,9 +157,6 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			return E_ERROR;
 		}
 
-		// Validate merged profile configuration upfront before executing any sync items.
-		// Identity credentials (ClientId/TenantId) are now included because they may be
-		// supplied via CLI overrides (--client-id, --tenant-id) and are already merged above.
 		try
 		{
 			var validator = serviceProvider.GetRequiredService<IConfigurationValidator>();
@@ -160,174 +168,37 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			return E_ERROR;
 		}
 
-		var success = true;
+		var ctx = new ProfileExecutionContext(
+			SolutionName: mergedProfile.SolutionName,
+			DryRun: mergedConfig.DryRun,
+			CiMode: mergedConfig.CiMode,
+			LogLevel: mergedConfig.LogLevel,
+			ProfileName: sharedOptions.ProfileName);
 
-		// Create argument overrides DTO from merged config values
-		var overrides = new ArgumentOverrides(mergedConfig.DryRun, mergedConfig.CiMode, mergedConfig.LogLevel);
+		var success = true;
 
-		// Execute each sync item in the merged profile
 		foreach (var syncItem in mergedProfile.Sync)
 		{
 			logger.LogInformation("Executing {syncType} sync item...", syncItem.SyncType);
 
-			int result = syncItem switch
+			int? result = null;
+			foreach (var cmd in subCommands)
 			{
-				PluginSyncItem plugin => await ExecutePluginSync(plugin, mergedProfile, sharedOptions, overrides, mergedConfig),
-				PluginAnalysisSyncItem analysis => await ExecutePluginAnalysis(analysis, sharedOptions),
-				WebresourceSyncItem webresource => await ExecuteWebresourceSync(webresource, mergedProfile, sharedOptions, overrides, mergedConfig),
-				IdentitySyncItem identity when identity.Operation == null => LogMissingIdentityOperation(logger),
-			IdentitySyncItem identity => await ExecuteIdentity(identity, mergedProfile, sharedOptions, overrides, mergedConfig),
-				_ => LogUnknownSyncItemType(logger, syncItem.SyncType)
-			};
+				result = await cmd.ExecuteFromProfile(syncItem, ctx, cancellationToken);
+				if (result.HasValue) break;
+			}
 
-			success = success && result == E_OK;
+			if (!result.HasValue)
+			{
+				logger.LogError("Unknown sync item type: {syncType}", syncItem.SyncType);
+				success = false;
+			}
+			else
+			{
+				success = success && result.Value == E_OK;
+			}
 		}
 
 		return success ? E_OK : E_ERROR;
 	}
-
-	private async Task<int> ExecutePluginSync(
-		PluginSyncItem syncItem,
-		ProfileConfiguration profile,
-		SharedOptions sharedOptions,
-		ArgumentOverrides overrides,
-		XrmSyncConfiguration config)
-	{
-		var args = new List<string>
-		{
-			CliOptions.Assembly.Primary, syncItem.AssemblyPath,
-			CliOptions.Solution.Primary, profile.SolutionName
-		};
-
-		if (!string.IsNullOrWhiteSpace(sharedOptions.ProfileName))
-		{
-			args.Add(CliOptions.Config.Profile.Primary);
-			args.Add(sharedOptions.ProfileName);
-		}
-
-		AddCommonArgs(args, overrides, config);
-		return await ExecuteSubCommand("plugins", [.. args]);
-	}
-
-	private async Task<int> ExecutePluginAnalysis(
-		PluginAnalysisSyncItem syncItem,
-		SharedOptions sharedOptions)
-	{
-		var args = new List<string>
-		{
-			CliOptions.Assembly.Primary, syncItem.AssemblyPath,
-			CliOptions.Analysis.Prefix.Primary, syncItem.PublisherPrefix
-		};
-
-		if (!string.IsNullOrWhiteSpace(sharedOptions.ProfileName))
-		{
-			args.Add(CliOptions.Config.Profile.Primary);
-			args.Add(sharedOptions.ProfileName);
-		}
-
-		if (syncItem.PrettyPrint)
-			args.Add(CliOptions.Analysis.PrettyPrint.Primary);
-
-		return await ExecuteSubCommand("analyze", [.. args]);
-	}
-
-	private async Task<int> ExecuteWebresourceSync(
-		WebresourceSyncItem syncItem,
-		ProfileConfiguration profile,
-		SharedOptions sharedOptions,
-		ArgumentOverrides overrides,
-		XrmSyncConfiguration config)
-	{
-		var args = new List<string>
-		{
-			CliOptions.Webresource.Primary, syncItem.FolderPath,
-			CliOptions.Solution.Primary, profile.SolutionName
-		};
-
-		if (syncItem.FileExtensions is { Count: > 0 })
-		{
-			args.Add(CliOptions.FileExtensions.Primary);
-			args.AddRange(syncItem.FileExtensions);
-		}
-
-		if (!string.IsNullOrWhiteSpace(sharedOptions.ProfileName))
-		{
-			args.Add(CliOptions.Config.Profile.Primary);
-			args.Add(sharedOptions.ProfileName);
-		}
-
-		AddCommonArgs(args, overrides, config);
-		return await ExecuteSubCommand("webresources", [.. args]);
-	}
-
-	private async Task<int> ExecuteIdentity(
-		IdentitySyncItem syncItem,
-		ProfileConfiguration profile,
-		SharedOptions sharedOptions,
-		ArgumentOverrides overrides,
-		XrmSyncConfiguration config)
-	{
-		var args = new List<string>
-		{
-			CliOptions.ManagedIdentity.Operation.Primary, syncItem.Operation!.Value.ToString(),
-			CliOptions.Assembly.Primary, syncItem.AssemblyPath,
-			CliOptions.Solution.Primary, profile.SolutionName
-		};
-
-		if (syncItem.Operation == IdentityOperation.Ensure)
-		{
-			// Values are guaranteed non-empty at this point (validation passed)
-			if (!string.IsNullOrWhiteSpace(syncItem.ClientId))
-				args.AddRange([CliOptions.ManagedIdentity.ClientId.Primary, syncItem.ClientId]);
-			if (!string.IsNullOrWhiteSpace(syncItem.TenantId))
-				args.AddRange([CliOptions.ManagedIdentity.TenantId.Primary, syncItem.TenantId]);
-		}
-
-		if (!string.IsNullOrWhiteSpace(sharedOptions.ProfileName))
-		{
-			args.Add(CliOptions.Config.Profile.Primary);
-			args.Add(sharedOptions.ProfileName);
-		}
-
-		AddCommonArgs(args, overrides, config);
-		return await ExecuteSubCommand("identity", [.. args]);
-	}
-
-	private static void AddCommonArgs(List<string> args, ArgumentOverrides overrides, XrmSyncConfiguration config)
-	{
-		// Use override if provided, otherwise use config value
-		if (overrides.DryRun || config.DryRun)
-			args.Add(CliOptions.Execution.DryRun.Primary);
-
-		if (overrides.CiMode || config.CiMode)
-			args.Add(CliOptions.Logging.CiMode.Aliases[0]);
-
-		var logLevel = overrides.LogLevel ?? config.LogLevel;
-		args.AddRange([CliOptions.Logging.LogLevel.Primary, logLevel.ToString()]);
-	}
-
-	private static int LogUnknownSyncItemType(ILogger logger, string syncType)
-	{
-		logger.LogError("Unknown sync item type: {syncType}", syncType);
-		return E_ERROR;
-	}
-
-	private static int LogMissingIdentityOperation(ILogger logger)
-	{
-		logger.LogError("Identity sync item has no operation configured and none was supplied via --operation.");
-		return E_ERROR;
-	}
-
-	private async Task<int> ExecuteSubCommand(string commandName, string[] args)
-	{
-		var command = subCommands.FirstOrDefault(c => c.GetCommand().Name == commandName);
-		if (command == null)
-		{
-			Console.Error.WriteLine($"Sub-command '{commandName}' not found.");
-			return E_ERROR;
-		}
-
-		var parseResult = command.GetCommand().Parse(args);
-		return await parseResult.InvokeAsync();
-	}
 }
diff --git a/XrmSync/Commands/XrmSyncSyncCommandBase.cs b/XrmSync/Commands/XrmSyncSyncCommandBase.cs
deleted file mode 100644
index c30d543..0000000
--- a/XrmSync/Commands/XrmSyncSyncCommandBase.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using System.CommandLine;
-using XrmSync.Constants;
-using XrmSync.Model.Exceptions;
-using XrmSync.SyncService;
-
-namespace XrmSync.Commands
-{
-	internal abstract class XrmSyncSyncCommandBase(string name, string description) : XrmSyncCommandBase(name, description)
-	{
-		protected Option<string> SolutionName { get; private set; } = null!;
-		protected Option<bool?> DryRun { get; private set; } = null!;
-		protected Option<LogLevel?> LogLevel { get; private set; } = null!;
-		protected Option<bool?> CiMode { get; private set; } = null!;
-
-		protected virtual void AddSyncSharedOptions()
-		{
-			SolutionName = CliOptions.Solution.CreateOption<string>();
-			DryRun = CliOptions.Execution.DryRun.CreateOption<bool?>();
-			LogLevel = CliOptions.Logging.LogLevel.CreateOption<LogLevel?>();
-			CiMode = CliOptions.Logging.CiMode.CreateOption<bool?>();
-
-			Add(SolutionName);
-			Add(DryRun);
-			Add(LogLevel);
-			Add(CiMode);
-		}
-
-		protected (string? SolutionName, bool? DryRun, LogLevel? LogLevel, bool? CIMode) GetSyncSharedOptionValues(ParseResult parseResult)
-		{
-			var solutionName = parseResult.GetValue(SolutionName);
-			var dryRun = parseResult.GetValue(DryRun);
-			var logLevel = parseResult.GetValue(LogLevel);
-			var ciMode = parseResult.GetValue(CiMode);
-
-			return (solutionName, dryRun, logLevel, ciMode);
-		}
-
-		protected static async Task<bool> CommandAction(IServiceProvider serviceProvider, CancellationToken cancellationToken)
-		{
-			var logger = serviceProvider.GetRequiredService<ILogger<XrmSyncSyncCommandBase>>();
-			try
-			{
-				var syncService = serviceProvider.GetRequiredService<ISyncService>();
-				await syncService.Sync(cancellationToken);
-				return true;
-			}
-			catch (OptionsValidationException ex)
-			{
-				logger.LogCritical("Configuration validation failed:{nl}{message}", Environment.NewLine, ex.Message);
-				return false;
-			}
-			catch (XrmSyncException ex)
-			{
-				logger.LogError("Error during synchronization: {message}", ex.Message);
-				return false;
-			}
-			catch (Exception ex)
-			{
-				logger.LogCritical(ex, "An unexpected error occurred during synchronization: {message}", ex.Message);
-				return false;
-			}
-		}
-	}
-}

From fe05fa69e828770b6c93bc0dd7842ae30f79899b Mon Sep 17 00:00:00 2001
From: Morten Holt <mkh@contextand.com>
Date: Thu, 23 Apr 2026 13:39:53 +0200
Subject: [PATCH 2/6] Fix: Pass exception to LogCritical

---
 XrmSync/Commands/XrmSyncRootCommand.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/XrmSync/Commands/XrmSyncRootCommand.cs b/XrmSync/Commands/XrmSyncRootCommand.cs
index 0e361bb..c66ac40 100644
--- a/XrmSync/Commands/XrmSyncRootCommand.cs
+++ b/XrmSync/Commands/XrmSyncRootCommand.cs
@@ -164,7 +164,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		}
 		catch (Exception ex)
 		{
-			logger.LogCritical("Configuration validation failed — aborting:{nl}{message}", Environment.NewLine, ex.Message);
+			logger.LogCritical(ex, "Configuration validation failed — aborting:{nl}{message}", Environment.NewLine, ex.Message);
 			return E_ERROR;
 		}
 

From 2b76db2da9ed79ca25a61de174f3c266a62668ce Mon Sep 17 00:00:00 2001
From: Morten Holt <mkh@contextand.com>
Date: Thu, 23 Apr 2026 14:21:15 +0200
Subject: [PATCH 3/6] Fix: Client and Tenant IDs are no long nullable to
 simplify API Fix: Use string extention to do the fallback logic

---
 Model/XrmSyncOptions.cs                       |  6 +-
 Tests/Config/NamedConfigurationTests.cs       |  4 +-
 Tests/Config/OptionsValidationTests.cs        |  6 +-
 .../IdentitySyncServiceTests.cs               | 91 +++++++++----------
 XrmSync/Commands/IdentityCommand.cs           | 28 +++---
 XrmSync/Commands/PluginAnalyzeCommand.cs      |  4 +-
 XrmSync/Commands/PluginSyncCommand.cs         |  4 +-
 XrmSync/Commands/WebresourceSyncCommand.cs    |  6 +-
 XrmSync/Commands/XrmSyncRootCommand.cs        | 20 ++--
 XrmSync/Extensions/StringExtensions.cs        |  6 ++
 .../Options/XrmSyncConfigurationBuilder.cs    |  5 +-
 11 files changed, 92 insertions(+), 88 deletions(-)
 create mode 100644 XrmSync/Extensions/StringExtensions.cs

diff --git a/Model/XrmSyncOptions.cs b/Model/XrmSyncOptions.cs
index ab4bf37..52b361e 100644
--- a/Model/XrmSyncOptions.cs
+++ b/Model/XrmSyncOptions.cs
@@ -119,7 +119,7 @@ public enum IdentityOperation
 	Ensure
 }
 
-public record IdentitySyncItem(IdentityOperation? Operation = null, string AssemblyPath = "", string? ClientId = null, string? TenantId = null) : SyncItem
+public record IdentitySyncItem(IdentityOperation? Operation = null, string AssemblyPath = "", string ClientId = "", string TenantId = "") : SyncItem
 {
 	public const string TypeName = "Identity";
 	public static IdentitySyncItem Empty => new(AssemblyPath: string.Empty);
@@ -128,9 +128,9 @@ public record IdentitySyncItem(IdentityOperation? Operation = null, string Assem
 	public override string SyncType => Operation.HasValue ? $"{TypeName} ({Operation})" : TypeName;
 }
 
-public record IdentityCommandOptions(IdentityOperation Operation, string AssemblyPath, string SolutionName, string? ClientId = null, string? TenantId = null)
+public record IdentityCommandOptions(IdentityOperation Operation, string AssemblyPath, string SolutionName, string ClientId, string TenantId)
 {
-	public static IdentityCommandOptions Empty => new(IdentityOperation.Remove, string.Empty, string.Empty);
+	public static IdentityCommandOptions Empty => new(IdentityOperation.Remove, string.Empty, string.Empty, string.Empty, string.Empty);
 }
 
 public record ExecutionModeOptions(bool DryRun)
diff --git a/Tests/Config/NamedConfigurationTests.cs b/Tests/Config/NamedConfigurationTests.cs
index 63ddb8e..60513bf 100644
--- a/Tests/Config/NamedConfigurationTests.cs
+++ b/Tests/Config/NamedConfigurationTests.cs
@@ -366,8 +366,8 @@ public void IdentityRemoveSyncItemParsesFromConfig()
 			var identitySync = Assert.IsType<IdentitySyncItem>(profile.Sync[0]);
 			Assert.Equal(IdentityOperation.Remove, identitySync.Operation);
 			Assert.Equal("plugins.dll", identitySync.AssemblyPath);
-			Assert.Null(identitySync.ClientId);
-			Assert.Null(identitySync.TenantId);
+			Assert.Empty(identitySync.ClientId);
+			Assert.Empty(identitySync.TenantId);
 		}
 		finally
 		{
diff --git a/Tests/Config/OptionsValidationTests.cs b/Tests/Config/OptionsValidationTests.cs
index 8e9deb9..190b593 100644
--- a/Tests/Config/OptionsValidationTests.cs
+++ b/Tests/Config/OptionsValidationTests.cs
@@ -579,7 +579,7 @@ public void IdentityEnsureValidatorMissingClientIdThrowsValidationException()
 				{
 					new("default", "TestSolution", new List<SyncItem>
 					{
-						new IdentitySyncItem(IdentityOperation.Ensure, dllPath, null, "a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d")
+						new IdentitySyncItem(IdentityOperation.Ensure, dllPath, string.Empty, "a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d")
 					})
 				}
 			);
@@ -618,7 +618,7 @@ public void IdentityEnsureValidatorMissingTenantIdThrowsValidationException()
 				{
 					new("default", "TestSolution", new List<SyncItem>
 					{
-						new IdentitySyncItem(IdentityOperation.Ensure, dllPath, "d3b5e6a1-2c4f-4a8b-9e1d-7f3c6b8a2e4d", null)
+						new IdentitySyncItem(IdentityOperation.Ensure, dllPath, "d3b5e6a1-2c4f-4a8b-9e1d-7f3c6b8a2e4d", string.Empty)
 					})
 				}
 			);
@@ -696,7 +696,7 @@ public void IdentityRemoveValidatorDoesNotRequireClientIdOrTenantId()
 				{
 					new("default", "TestSolution", new List<SyncItem>
 					{
-						new IdentitySyncItem(IdentityOperation.Remove, dllPath, null, null)
+						new IdentitySyncItem(IdentityOperation.Remove, dllPath, string.Empty, string.Empty)
 					})
 				}
 			);
diff --git a/Tests/ManagedIdentity/IdentitySyncServiceTests.cs b/Tests/ManagedIdentity/IdentitySyncServiceTests.cs
index 44cf519..c179d6d 100644
--- a/Tests/ManagedIdentity/IdentitySyncServiceTests.cs
+++ b/Tests/ManagedIdentity/IdentitySyncServiceTests.cs
@@ -6,18 +6,17 @@
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
 using XrmSync.SyncService;
-using XrmSync.SyncService.Difference;
 
 namespace Tests.ManagedIdentity;
 
 public class IdentitySyncServiceTests
 {
-	private readonly ISolutionReader _solutionReader = Substitute.For<ISolutionReader>();
-	private readonly IManagedIdentityReader _managedIdentityReader = Substitute.For<IManagedIdentityReader>();
-	private readonly IManagedIdentityWriter _managedIdentityWriter = Substitute.For<IManagedIdentityWriter>();
-	private readonly ILogger<IdentitySyncService> _logger = Substitute.For<ILogger<IdentitySyncService>>();
+	private readonly ISolutionReader solutionReader = Substitute.For<ISolutionReader>();
+	private readonly IManagedIdentityReader managedIdentityReader = Substitute.For<IManagedIdentityReader>();
+	private readonly IManagedIdentityWriter managedIdentityWriter = Substitute.For<IManagedIdentityWriter>();
+	private readonly ILogger<IdentitySyncService> logger = Substitute.For<ILogger<IdentitySyncService>>();
 
-	private readonly Guid _solutionId = Guid.NewGuid();
+	private readonly Guid solutionId = Guid.NewGuid();
 	private const string SolutionName = "TestSolution";
 	private const string AssemblyPath = "path/to/MyPlugin.dll";
 
@@ -30,15 +29,15 @@ private IdentitySyncService CreateService(
 			operation,
 			assemblyPath ?? AssemblyPath,
 			solutionName ?? SolutionName,
-			clientId,
-			tenantId);
+			clientId ?? string.Empty,
+			tenantId ?? string.Empty);
 
 		return new IdentitySyncService(
-			_solutionReader,
-			_managedIdentityReader,
-			_managedIdentityWriter,
+			solutionReader,
+			managedIdentityReader,
+			managedIdentityWriter,
 			Options.Create(options),
-			_logger);
+			logger);
 	}
 
 	// --- Remove operation tests ---
@@ -51,8 +50,8 @@ public async Task RemoveDeletesManagedIdentityWhenLinkedToAssembly()
 		var miId = Guid.NewGuid();
 		var miRef = new EntityReference("managedidentity", miId);
 
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns((assemblyId, miRef));
 
 		var service = CreateService(IdentityOperation.Remove);
@@ -61,7 +60,7 @@ public async Task RemoveDeletesManagedIdentityWhenLinkedToAssembly()
 		await service.Sync(CancellationToken.None);
 
 		// Assert
-		_managedIdentityWriter.Received(1).Remove(miId);
+		managedIdentityWriter.Received(1).Remove(miId);
 	}
 
 	[Fact]
@@ -70,8 +69,8 @@ public async Task RemoveDoesNotDeleteWhenNoManagedIdentityLinked()
 		// Arrange
 		var assemblyId = Guid.NewGuid();
 
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns((assemblyId, (EntityReference?)null));
 
 		var service = CreateService(IdentityOperation.Remove);
@@ -80,15 +79,15 @@ public async Task RemoveDoesNotDeleteWhenNoManagedIdentityLinked()
 		await service.Sync(CancellationToken.None);
 
 		// Assert
-		_managedIdentityWriter.DidNotReceive().Remove(Arg.Any<Guid>());
+		managedIdentityWriter.DidNotReceive().Remove(Arg.Any<Guid>());
 	}
 
 	[Fact]
 	public async Task RemoveThrowsWhenAssemblyNotFound()
 	{
 		// Arrange
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns(((Guid, EntityReference?)?)null);
 
 		var service = CreateService(IdentityOperation.Remove);
@@ -106,8 +105,8 @@ public async Task RemoveDerivesAssemblyNameFromPath()
 		// Arrange
 		var assemblyId = Guid.NewGuid();
 
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "Custom.Plugin.Assembly")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "Custom.Plugin.Assembly")
 			.Returns((assemblyId, (EntityReference?)null));
 
 		var service = CreateService(IdentityOperation.Remove, assemblyPath: "some/nested/path/Custom.Plugin.Assembly.dll");
@@ -116,7 +115,7 @@ public async Task RemoveDerivesAssemblyNameFromPath()
 		await service.Sync(CancellationToken.None);
 
 		// Assert
-		_managedIdentityReader.Received(1).GetPluginAssemblyManagedIdentity(_solutionId, "Custom.Plugin.Assembly");
+		managedIdentityReader.Received(1).GetPluginAssemblyManagedIdentity(solutionId, "Custom.Plugin.Assembly");
 	}
 
 	// --- Ensure operation tests ---
@@ -130,10 +129,10 @@ public async Task EnsureCreatesManagedIdentityAndLinksToAssembly()
 		var clientId = Guid.NewGuid();
 		var tenantId = Guid.NewGuid();
 
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns((assemblyId, (EntityReference?)null));
-		_managedIdentityWriter.Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>())
+		managedIdentityWriter.Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>())
 			.Returns(createdMiId);
 
 		var service = CreateService(IdentityOperation.Ensure, clientId: clientId.ToString(), tenantId: tenantId.ToString());
@@ -142,10 +141,10 @@ public async Task EnsureCreatesManagedIdentityAndLinksToAssembly()
 		await service.Sync(CancellationToken.None);
 
 		// Assert - MI was created with correct values
-		_managedIdentityWriter.Received(1).Create("TestSolution Managed Identity", clientId, tenantId);
+		managedIdentityWriter.Received(1).Create("TestSolution Managed Identity", clientId, tenantId);
 
 		// Assert - Assembly was linked to the new MI
-		_managedIdentityWriter.Received(1).LinkToAssembly(assemblyId, createdMiId);
+		managedIdentityWriter.Received(1).LinkToAssembly(assemblyId, createdMiId);
 	}
 
 	[Fact]
@@ -155,8 +154,8 @@ public async Task EnsureNoOpsWhenManagedIdentityAlreadyLinked()
 		var assemblyId = Guid.NewGuid();
 		var existingMiRef = new EntityReference("managedidentity", Guid.NewGuid());
 
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns((assemblyId, existingMiRef));
 
 		var service = CreateService(IdentityOperation.Ensure,
@@ -166,15 +165,15 @@ public async Task EnsureNoOpsWhenManagedIdentityAlreadyLinked()
 		await service.Sync(CancellationToken.None);
 
 		// Assert
-		_managedIdentityWriter.DidNotReceive().Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>());
-		_managedIdentityWriter.DidNotReceive().LinkToAssembly(Arg.Any<Guid>(), Arg.Any<Guid>());
+		managedIdentityWriter.DidNotReceive().Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>());
+		managedIdentityWriter.DidNotReceive().LinkToAssembly(Arg.Any<Guid>(), Arg.Any<Guid>());
 	}
 
 	[Fact]
 	public async Task EnsureThrowsWhenClientIdIsNull()
 	{
 		// Arrange
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
 		var service = CreateService(IdentityOperation.Ensure, clientId: null, tenantId: Guid.NewGuid().ToString());
 
 		// Act & Assert
@@ -186,7 +185,7 @@ public async Task EnsureThrowsWhenClientIdIsNull()
 	public async Task EnsureThrowsWhenClientIdIsNotAValidGuid()
 	{
 		// Arrange
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
 		var service = CreateService(IdentityOperation.Ensure, clientId: "not-a-guid", tenantId: Guid.NewGuid().ToString());
 
 		// Act & Assert
@@ -198,7 +197,7 @@ public async Task EnsureThrowsWhenClientIdIsNotAValidGuid()
 	public async Task EnsureThrowsWhenTenantIdIsNull()
 	{
 		// Arrange
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
 		var service = CreateService(IdentityOperation.Ensure, clientId: Guid.NewGuid().ToString(), tenantId: null);
 
 		// Act & Assert
@@ -210,7 +209,7 @@ public async Task EnsureThrowsWhenTenantIdIsNull()
 	public async Task EnsureThrowsWhenTenantIdIsNotAValidGuid()
 	{
 		// Arrange
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
 		var service = CreateService(IdentityOperation.Ensure, clientId: Guid.NewGuid().ToString(), tenantId: "not-a-guid");
 
 		// Act & Assert
@@ -222,8 +221,8 @@ public async Task EnsureThrowsWhenTenantIdIsNotAValidGuid()
 	public async Task EnsureThrowsWhenAssemblyNotFound()
 	{
 		// Arrange
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns(((Guid, EntityReference?)?)null);
 
 		var service = CreateService(IdentityOperation.Ensure,
@@ -242,10 +241,10 @@ public async Task EnsureUsesSolutionNameForManagedIdentityName()
 		// Arrange
 		var assemblyId = Guid.NewGuid();
 
-		_solutionReader.RetrieveSolution("CustomSolution").Returns((_solutionId, "custom"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "MyPlugin")
+		solutionReader.RetrieveSolution("CustomSolution").Returns((solutionId, "custom"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "MyPlugin")
 			.Returns((assemblyId, (EntityReference?)null));
-		_managedIdentityWriter.Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>())
+		managedIdentityWriter.Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>())
 			.Returns(Guid.NewGuid());
 
 		var service = CreateService(IdentityOperation.Ensure, solutionName: "CustomSolution",
@@ -255,7 +254,7 @@ public async Task EnsureUsesSolutionNameForManagedIdentityName()
 		await service.Sync(CancellationToken.None);
 
 		// Assert
-		_managedIdentityWriter.Received(1).Create(
+		managedIdentityWriter.Received(1).Create(
 			"CustomSolution Managed Identity", Arg.Any<Guid>(), Arg.Any<Guid>());
 	}
 
@@ -265,10 +264,10 @@ public async Task EnsureDerivesAssemblyNameFromPath()
 		// Arrange
 		var assemblyId = Guid.NewGuid();
 
-		_solutionReader.RetrieveSolution(SolutionName).Returns((_solutionId, "test"));
-		_managedIdentityReader.GetPluginAssemblyManagedIdentity(_solutionId, "Custom.Plugin.Assembly")
+		solutionReader.RetrieveSolution(SolutionName).Returns((solutionId, "test"));
+		managedIdentityReader.GetPluginAssemblyManagedIdentity(solutionId, "Custom.Plugin.Assembly")
 			.Returns((assemblyId, (EntityReference?)null));
-		_managedIdentityWriter.Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>())
+		managedIdentityWriter.Create(Arg.Any<string>(), Arg.Any<Guid>(), Arg.Any<Guid>())
 			.Returns(Guid.NewGuid());
 
 		var service = CreateService(IdentityOperation.Ensure, assemblyPath: "some/nested/path/Custom.Plugin.Assembly.dll",
@@ -278,6 +277,6 @@ public async Task EnsureDerivesAssemblyNameFromPath()
 		await service.Sync(CancellationToken.None);
 
 		// Assert
-		_managedIdentityReader.Received(1).GetPluginAssemblyManagedIdentity(_solutionId, "Custom.Plugin.Assembly");
+		managedIdentityReader.Received(1).GetPluginAssemblyManagedIdentity(solutionId, "Custom.Plugin.Assembly");
 	}
 }
diff --git a/XrmSync/Commands/IdentityCommand.cs b/XrmSync/Commands/IdentityCommand.cs
index 2655e25..588ecaa 100644
--- a/XrmSync/Commands/IdentityCommand.cs
+++ b/XrmSync/Commands/IdentityCommand.cs
@@ -73,8 +73,8 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		IdentityOperation? finalOperation;
 		string finalAssemblyPath;
 		string finalSolutionName;
-		string? finalClientId;
-		string? finalTenantId;
+		string finalClientId;
+		string finalTenantId;
 
 		if (sharedOptions.ProfileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(solutionName))
 		{
@@ -82,8 +82,8 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			finalOperation = operationValue;
 			finalAssemblyPath = assemblyPath;
 			finalSolutionName = solutionName;
-			finalClientId = clientIdValue;
-			finalTenantId = tenantIdValue;
+			finalClientId = clientIdValue ?? string.Empty;
+			finalTenantId = tenantIdValue ?? string.Empty;
 		}
 		else
 		{
@@ -107,10 +107,10 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 				: identityItems.FirstOrDefault();
 
 			finalOperation = operationValue ?? syncItem?.Operation;
-			finalAssemblyPath = !string.IsNullOrWhiteSpace(assemblyPath) ? assemblyPath : (syncItem?.AssemblyPath ?? string.Empty);
-			finalSolutionName = !string.IsNullOrWhiteSpace(solutionName) ? solutionName : profile.SolutionName;
-			finalClientId = !string.IsNullOrWhiteSpace(clientIdValue) ? clientIdValue : syncItem?.ClientId;
-			finalTenantId = !string.IsNullOrWhiteSpace(tenantIdValue) ? tenantIdValue : syncItem?.TenantId;
+			finalAssemblyPath = assemblyPath.GetValueOrDefault(syncItem?.AssemblyPath ?? string.Empty);
+			finalSolutionName = solutionName.GetValueOrDefault(profile.SolutionName);
+			finalClientId = clientIdValue.GetValueOrDefault(syncItem?.ClientId ?? string.Empty);
+			finalTenantId = tenantIdValue.GetValueOrDefault(syncItem?.TenantId ?? string.Empty);
 		}
 
 		// Validate resolved values
@@ -124,8 +124,8 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 
 		if (finalOperation == IdentityOperation.Ensure)
 		{
-			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(finalClientId ?? string.Empty, "Client ID"));
-			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(finalTenantId ?? string.Empty, "Tenant ID"));
+			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(finalClientId, "Client ID"));
+			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(finalTenantId, "Tenant ID"));
 		}
 
 		if (errors.Count > 0)
@@ -138,8 +138,8 @@ private async Task<int> RunCore(
 		IdentityOperation operation,
 		string assemblyPath,
 		string solutionName,
-		string? clientId,
-		string? tenantId,
+		string clientId,
+		string tenantId,
 		bool? dryRun,
 		bool? ciMode,
 		LogLevel? logLevel,
@@ -153,8 +153,8 @@ private async Task<int> RunCore(
 
 		if (operation == IdentityOperation.Ensure)
 		{
-			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(clientId ?? string.Empty, "Client ID"));
-			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(tenantId ?? string.Empty, "Tenant ID"));
+			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(clientId, "Client ID"));
+			errors.AddRange(XrmSyncConfigurationValidator.ValidateGuid(tenantId, "Tenant ID"));
 		}
 
 		if (errors.Count > 0)
diff --git a/XrmSync/Commands/PluginAnalyzeCommand.cs b/XrmSync/Commands/PluginAnalyzeCommand.cs
index cd38501..3544fbc 100644
--- a/XrmSync/Commands/PluginAnalyzeCommand.cs
+++ b/XrmSync/Commands/PluginAnalyzeCommand.cs
@@ -74,8 +74,8 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			// Sync item is optional — if absent, CLI must supply all analysis-specific values
 			var pluginAnalysisItem = profile.Sync.OfType<PluginAnalysisSyncItem>().FirstOrDefault();
 
-			finalAssemblyPath = !string.IsNullOrWhiteSpace(assemblyPath) ? assemblyPath : (pluginAnalysisItem?.AssemblyPath ?? string.Empty);
-			finalPublisherPrefix = !string.IsNullOrWhiteSpace(publisherPrefix) ? publisherPrefix : (pluginAnalysisItem?.PublisherPrefix ?? string.Empty);
+			finalAssemblyPath = assemblyPath.GetValueOrDefault(pluginAnalysisItem?.AssemblyPath ?? string.Empty);
+			finalPublisherPrefix = publisherPrefix.GetValueOrDefault(pluginAnalysisItem?.PublisherPrefix ?? string.Empty);
 			finalPrettyPrint = prettyPrintValue || (pluginAnalysisItem?.PrettyPrint ?? false);
 		}
 
diff --git a/XrmSync/Commands/PluginSyncCommand.cs b/XrmSync/Commands/PluginSyncCommand.cs
index 7ca03d2..0b3a3c9 100644
--- a/XrmSync/Commands/PluginSyncCommand.cs
+++ b/XrmSync/Commands/PluginSyncCommand.cs
@@ -65,8 +65,8 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			// Sync item is optional — if absent, CLI must supply all plugin-specific values
 			var pluginSyncItem = profile.Sync.OfType<PluginSyncItem>().FirstOrDefault();
 
-			finalAssemblyPath = !string.IsNullOrWhiteSpace(assemblyPath) ? assemblyPath : (pluginSyncItem?.AssemblyPath ?? string.Empty);
-			finalSolutionName = !string.IsNullOrWhiteSpace(solutionName) ? solutionName : profile.SolutionName;
+			finalAssemblyPath = assemblyPath.GetValueOrDefault(pluginSyncItem?.AssemblyPath ?? string.Empty);
+			finalSolutionName = solutionName.GetValueOrDefault(profile.SolutionName);
 		}
 
 		return await RunCore(finalAssemblyPath, finalSolutionName, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
diff --git a/XrmSync/Commands/WebresourceSyncCommand.cs b/XrmSync/Commands/WebresourceSyncCommand.cs
index ec713e9..7feb472 100644
--- a/XrmSync/Commands/WebresourceSyncCommand.cs
+++ b/XrmSync/Commands/WebresourceSyncCommand.cs
@@ -71,9 +71,9 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 				// Sync item is optional — if absent, CLI must supply all webresource-specific values
 				var webresourceSyncItem = profile.Sync.OfType<WebresourceSyncItem>().FirstOrDefault();
 
-				finalFolderPath = !string.IsNullOrWhiteSpace(folderPath) ? folderPath : (webresourceSyncItem?.FolderPath ?? string.Empty);
-				finalSolutionName = !string.IsNullOrWhiteSpace(solutionName) ? solutionName : profile.SolutionName;
-				finalExtensions = extensionsValue is { Length: > 0 } ? extensionsValue.ToList() : webresourceSyncItem?.FileExtensions;
+				finalFolderPath = folderPath.GetValueOrDefault(webresourceSyncItem?.FolderPath ?? string.Empty);
+				finalSolutionName = solutionName.GetValueOrDefault(profile.SolutionName);
+				finalExtensions = extensionsValue is { Length: > 0 } ? [.. extensionsValue] : webresourceSyncItem?.FileExtensions;
 			}
 
 			return await RunCore(finalFolderPath, finalSolutionName, finalExtensions, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
diff --git a/XrmSync/Commands/XrmSyncRootCommand.cs b/XrmSync/Commands/XrmSyncRootCommand.cs
index c66ac40..e2674a1 100644
--- a/XrmSync/Commands/XrmSyncRootCommand.cs
+++ b/XrmSync/Commands/XrmSyncRootCommand.cs
@@ -95,33 +95,33 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		}
 
 		// Merge CLI overrides into each sync item
-		var mergedSync = rawProfile.Sync.Select<SyncItem, SyncItem>(item => item switch
+		var mergedSync = rawProfile.Sync.ConvertAll(item => item switch
 		{
 			PluginSyncItem plugin => plugin with
 			{
-				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyOverride) ? assemblyOverride : plugin.AssemblyPath
+				AssemblyPath = assemblyOverride.GetValueOrDefault(plugin.AssemblyPath)
 			},
 			PluginAnalysisSyncItem analysis => analysis with
 			{
-				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyOverride) ? assemblyOverride : analysis.AssemblyPath,
-				PublisherPrefix = !string.IsNullOrWhiteSpace(prefixOverride) ? prefixOverride : analysis.PublisherPrefix
+				AssemblyPath = assemblyOverride.GetValueOrDefault(analysis.AssemblyPath),
+				PublisherPrefix = prefixOverride.GetValueOrDefault(analysis.PublisherPrefix)
 			},
 			WebresourceSyncItem webresource => webresource with
 			{
-				FolderPath = !string.IsNullOrWhiteSpace(folderOverride) ? folderOverride : webresource.FolderPath,
+				FolderPath = folderOverride.GetValueOrDefault(webresource.FolderPath),
 				FileExtensions = fileExtensionsOverride is { Length: > 0 } ? fileExtensionsOverride.ToList() : webresource.FileExtensions
 			},
 			IdentitySyncItem identity => identity with
 			{
 				Operation = operationOverride ?? identity.Operation,
-				AssemblyPath = !string.IsNullOrWhiteSpace(assemblyOverride) ? assemblyOverride : identity.AssemblyPath,
-				ClientId = !string.IsNullOrWhiteSpace(clientIdOverride) ? clientIdOverride : identity.ClientId,
-				TenantId = !string.IsNullOrWhiteSpace(tenantIdOverride) ? tenantIdOverride : identity.TenantId
+				AssemblyPath = assemblyOverride.GetValueOrDefault(identity.AssemblyPath),
+				ClientId = clientIdOverride.GetValueOrDefault(identity.ClientId),
+				TenantId = tenantIdOverride.GetValueOrDefault(identity.TenantId)
 			},
 			_ => item
-		}).ToList();
+		});
 
-		var mergedSolutionName = !string.IsNullOrWhiteSpace(solutionOverride) ? solutionOverride : rawProfile.SolutionName;
+		var mergedSolutionName = solutionOverride.GetValueOrDefault(rawProfile.SolutionName);
 		var mergedProfile = rawProfile with { SolutionName = mergedSolutionName, Sync = mergedSync };
 
 		var mergedConfig = rawConfig with
diff --git a/XrmSync/Extensions/StringExtensions.cs b/XrmSync/Extensions/StringExtensions.cs
new file mode 100644
index 0000000..7a5214f
--- /dev/null
+++ b/XrmSync/Extensions/StringExtensions.cs
@@ -0,0 +1,6 @@
+namespace XrmSync.Extensions;
+
+internal static class StringExtensions
+{
+	public static string GetValueOrDefault(this string? value, string defaultValue) => !string.IsNullOrWhiteSpace(value) ? value : defaultValue;
+}
diff --git a/XrmSync/Options/XrmSyncConfigurationBuilder.cs b/XrmSync/Options/XrmSyncConfigurationBuilder.cs
index 8b87d65..0b0b9cb 100644
--- a/XrmSync/Options/XrmSyncConfigurationBuilder.cs
+++ b/XrmSync/Options/XrmSyncConfigurationBuilder.cs
@@ -1,7 +1,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using XrmSync.Model;
-using XrmSync.Model.Exceptions;
 
 namespace XrmSync.Options;
 
@@ -115,8 +114,8 @@ private List<SyncItem> BuildSyncItems(IConfigurationSection syncSection)
 		return new IdentitySyncItem(
 			operation,
 			itemSection.GetValue<string>(nameof(IdentitySyncItem.AssemblyPath)) ?? string.Empty,
-			itemSection.GetValue<string>(nameof(IdentitySyncItem.ClientId)),
-			itemSection.GetValue<string>(nameof(IdentitySyncItem.TenantId))
+			itemSection.GetValue<string>(nameof(IdentitySyncItem.ClientId)) ?? string.Empty,
+			itemSection.GetValue<string>(nameof(IdentitySyncItem.TenantId)) ?? string.Empty
 		);
 	}
 

From 00275ec638ca86a1c396985fefe447b64748406f Mon Sep 17 00:00:00 2001
From: Morten Holt <mkh@contextand.com>
Date: Thu, 23 Apr 2026 16:08:33 +0200
Subject: [PATCH 4/6] Refactor: Centralize option definition and parsing and
 reduce double-code. Refactor: Combine a couple of records into the execution
 context record and pass that for dry run, profile and related

---
 AssemblyAnalyzer/GlobalUsings.cs              |  1 +
 AssemblyAnalyzer/Reader/LocalReader.cs        |  2 +-
 Dataverse/CustomApiWriter.cs                  |  1 +
 Dataverse/DataverseWriter.cs                  |  4 +-
 Dataverse/DryRunDataverseWriter.cs            |  4 +-
 .../Extensions/ServiceCollectionExtensions.cs |  5 +-
 Dataverse/GlobalUsings.cs                     |  1 +
 Dataverse/PluginAssemblyWriter.cs             |  1 +
 Model/ExecutionContext.cs                     | 17 ++++
 Model/Identity/IdentityCommandOptions.cs      |  7 ++
 Model/Plugin/PluginAnalysisCommandOptions.cs  |  7 ++
 Model/Plugin/PluginSyncCommandOptions.cs      |  8 ++
 .../WebresourceSyncCommandOptions.cs          |  7 ++
 Model/XrmSyncOptions.cs                       | 30 -------
 SyncService/Difference/PrintService.cs        |  4 +-
 SyncService/GlobalUsings.cs                   |  1 +
 SyncService/IdentitySyncService.cs            |  2 +-
 SyncService/WebresourceSyncService.cs         |  2 -
 Tests.Integration/GlobalUsings.cs             |  1 +
 Tests.Integration/Infrastructure/TestBase.cs  |  5 +-
 Tests/Config/ConfigValidateCommandTests.cs    | 14 ++--
 Tests/Config/OptionsValidationTests.cs        |  6 +-
 .../DifferenceCalculatorCustomApiTests.cs     |  2 +-
 Tests/GlobalUsings.cs                         |  1 +
 .../IdentitySyncServiceTests.cs               |  1 +
 Tests/Plugins/AssemblyReaderTests.cs          |  2 +-
 Tests/Plugins/DifferenceUtilityTests.cs       |  2 +-
 .../WebresourceSyncServiceTests.cs            |  1 -
 Tests/Webresources/WebresourceWriterTests.cs  |  1 -
 XrmSync/Commands/CommandOptions.cs            | 28 +++++++
 XrmSync/Commands/ConfigCommand.cs             |  2 +-
 XrmSync/Commands/ConfigValidateCommand.cs     |  3 +-
 XrmSync/Commands/IXrmSyncCommand.cs           |  2 +-
 XrmSync/Commands/IdentityCommand.cs           | 53 +++++--------
 XrmSync/Commands/PluginAnalyzeCommand.cs      | 33 ++++----
 XrmSync/Commands/PluginSyncCommand.cs         | 35 ++++----
 XrmSync/Commands/ProfileExecutionContext.cs   | 14 ----
 XrmSync/Commands/WebresourceSyncCommand.cs    | 41 ++++------
 XrmSync/Commands/XrmSyncCommandBase.cs        | 76 ++----------------
 XrmSync/Commands/XrmSyncRootCommand.cs        | 79 +++++++------------
 .../Extensions/ServiceCollectionExtensions.cs | 13 ++-
 XrmSync/GlobalUsings.cs                       |  1 +
 XrmSync/Options/ConfigValidationOutput.cs     |  2 +-
 .../Options/XrmSyncConfigurationValidator.cs  |  2 +-
 44 files changed, 223 insertions(+), 301 deletions(-)
 create mode 100644 AssemblyAnalyzer/GlobalUsings.cs
 create mode 100644 Dataverse/GlobalUsings.cs
 create mode 100644 Model/ExecutionContext.cs
 create mode 100644 Model/Identity/IdentityCommandOptions.cs
 create mode 100644 Model/Plugin/PluginAnalysisCommandOptions.cs
 create mode 100644 Model/Plugin/PluginSyncCommandOptions.cs
 create mode 100644 Model/Webresource/WebresourceSyncCommandOptions.cs
 create mode 100644 SyncService/GlobalUsings.cs
 create mode 100644 Tests.Integration/GlobalUsings.cs
 create mode 100644 Tests/GlobalUsings.cs
 create mode 100644 XrmSync/Commands/CommandOptions.cs
 delete mode 100644 XrmSync/Commands/ProfileExecutionContext.cs
 create mode 100644 XrmSync/GlobalUsings.cs

diff --git a/AssemblyAnalyzer/GlobalUsings.cs b/AssemblyAnalyzer/GlobalUsings.cs
new file mode 100644
index 0000000..23e2014
--- /dev/null
+++ b/AssemblyAnalyzer/GlobalUsings.cs
@@ -0,0 +1 @@
+global using ExecutionContext = XrmSync.Model.ExecutionContext;
diff --git a/AssemblyAnalyzer/Reader/LocalReader.cs b/AssemblyAnalyzer/Reader/LocalReader.cs
index d037324..e368967 100644
--- a/AssemblyAnalyzer/Reader/LocalReader.cs
+++ b/AssemblyAnalyzer/Reader/LocalReader.cs
@@ -7,7 +7,7 @@
 
 namespace XrmSync.Analyzer.Reader;
 
-internal class LocalReader(ILogger<LocalReader> logger, IOptions<SharedOptions> sharedOptions) : ILocalReader
+internal class LocalReader(ILogger<LocalReader> logger, IOptions<ExecutionContext> sharedOptions) : ILocalReader
 {
 	private readonly Dictionary<string, AssemblyInfo> assemblyCache = [];
 
diff --git a/Dataverse/CustomApiWriter.cs b/Dataverse/CustomApiWriter.cs
index 599bcb2..85a262e 100644
--- a/Dataverse/CustomApiWriter.cs
+++ b/Dataverse/CustomApiWriter.cs
@@ -5,6 +5,7 @@
 using XrmSync.Dataverse.Interfaces;
 using XrmSync.Model;
 using XrmSync.Model.CustomApi;
+using XrmSync.Model.Plugin;
 
 namespace XrmSync.Dataverse;
 
diff --git a/Dataverse/DataverseWriter.cs b/Dataverse/DataverseWriter.cs
index b428318..fc845e2 100644
--- a/Dataverse/DataverseWriter.cs
+++ b/Dataverse/DataverseWriter.cs
@@ -14,9 +14,9 @@ internal sealed class DataverseWriter : IDataverseWriter
 	private readonly IOrganizationService service;
 	private readonly ILogger<DataverseWriter> logger;
 
-	public DataverseWriter(IOrganizationServiceProvider serviceProvider, ILogger<DataverseWriter> logger, IOptions<ExecutionModeOptions> configuration)
+	public DataverseWriter(IOrganizationServiceProvider serviceProvider, ILogger<DataverseWriter> logger, IOptions<ExecutionContext> configuration)
 	{
-		if (configuration.Value.DryRun)
+		if (configuration.Value.DryRun == true)
 		{
 			throw new XrmSyncException("Cannot perform write operations in dry run mode. Please disable dry run to proceed with writing to Dataverse.");
 		}
diff --git a/Dataverse/DryRunDataverseWriter.cs b/Dataverse/DryRunDataverseWriter.cs
index e142e09..75d9e82 100644
--- a/Dataverse/DryRunDataverseWriter.cs
+++ b/Dataverse/DryRunDataverseWriter.cs
@@ -14,9 +14,9 @@ internal class DryRunDataverseWriter : IDataverseWriter
 {
 	private readonly ILogger<DryRunDataverseWriter> logger;
 
-	public DryRunDataverseWriter(IOptions<ExecutionModeOptions> configuration, ILogger<DryRunDataverseWriter> logger)
+	public DryRunDataverseWriter(IOptions<ExecutionContext> configuration, ILogger<DryRunDataverseWriter> logger)
 	{
-		if (!configuration.Value.DryRun)
+		if (configuration.Value.DryRun != true)
 		{
 			throw new XrmSyncException("This writer is intended for dry runs only.");
 		}
diff --git a/Dataverse/Extensions/ServiceCollectionExtensions.cs b/Dataverse/Extensions/ServiceCollectionExtensions.cs
index 107ab03..f92ec82 100644
--- a/Dataverse/Extensions/ServiceCollectionExtensions.cs
+++ b/Dataverse/Extensions/ServiceCollectionExtensions.cs
@@ -2,7 +2,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using XrmSync.Dataverse.Interfaces;
-using XrmSync.Model;
 
 namespace XrmSync.Dataverse.Extensions;
 
@@ -17,9 +16,9 @@ public static IServiceCollection AddDataverseServices(this IServiceCollection se
 		services.AddSingleton<IDataverseReader, DataverseReader>();
 		services.AddSingleton<IDataverseWriter>((sp) =>
 		{
-			var options = sp.GetRequiredService<IOptions<ExecutionModeOptions>>();
+			var options = sp.GetRequiredService<IOptions<ExecutionContext>>();
 
-			return options.Value.DryRun
+			return options.Value.DryRun == true
 				? ActivatorUtilities.CreateInstance<DryRunDataverseWriter>(sp)
 				: ActivatorUtilities.CreateInstance<DataverseWriter>(sp);
 		});
diff --git a/Dataverse/GlobalUsings.cs b/Dataverse/GlobalUsings.cs
new file mode 100644
index 0000000..23e2014
--- /dev/null
+++ b/Dataverse/GlobalUsings.cs
@@ -0,0 +1 @@
+global using ExecutionContext = XrmSync.Model.ExecutionContext;
diff --git a/Dataverse/PluginAssemblyWriter.cs b/Dataverse/PluginAssemblyWriter.cs
index 8de7195..9510d76 100644
--- a/Dataverse/PluginAssemblyWriter.cs
+++ b/Dataverse/PluginAssemblyWriter.cs
@@ -3,6 +3,7 @@
 using XrmSync.Dataverse.Interfaces;
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
+using XrmSync.Model.Plugin;
 
 namespace XrmSync.Dataverse;
 
diff --git a/Model/ExecutionContext.cs b/Model/ExecutionContext.cs
new file mode 100644
index 0000000..c6a80b5
--- /dev/null
+++ b/Model/ExecutionContext.cs
@@ -0,0 +1,17 @@
+using Microsoft.Extensions.Logging;
+
+namespace XrmSync.Model;
+
+/// <summary>
+/// Carries execution parameters resolved from configuration and CLI overrides.
+/// Used as the single DI-registered context replacing both SharedOptions and ExecutionModeOptions.
+/// </summary>
+public record ExecutionContext(
+	string? SolutionName,
+	bool? DryRun,
+	bool? CiMode,
+	LogLevel? LogLevel,
+	string? ProfileName)
+{
+	public static ExecutionContext Empty => new(null, null, null, null, null);
+}
diff --git a/Model/Identity/IdentityCommandOptions.cs b/Model/Identity/IdentityCommandOptions.cs
new file mode 100644
index 0000000..d9e0d45
--- /dev/null
+++ b/Model/Identity/IdentityCommandOptions.cs
@@ -0,0 +1,7 @@
+namespace XrmSync.Model.Identity;
+
+public record IdentityCommandOptions(IdentityOperation Operation, string AssemblyPath, string SolutionName, string ClientId, string TenantId)
+{
+	public static IdentityCommandOptions Empty => new(IdentityOperation.Remove, string.Empty, string.Empty, string.Empty, string.Empty);
+}
+
diff --git a/Model/Plugin/PluginAnalysisCommandOptions.cs b/Model/Plugin/PluginAnalysisCommandOptions.cs
new file mode 100644
index 0000000..ec2de79
--- /dev/null
+++ b/Model/Plugin/PluginAnalysisCommandOptions.cs
@@ -0,0 +1,7 @@
+namespace XrmSync.Model.Plugin;
+
+public record PluginAnalysisCommandOptions(string AssemblyPath, string PublisherPrefix, bool PrettyPrint)
+{
+	public static PluginAnalysisCommandOptions Empty => new(string.Empty, "new", false);
+}
+
diff --git a/Model/Plugin/PluginSyncCommandOptions.cs b/Model/Plugin/PluginSyncCommandOptions.cs
new file mode 100644
index 0000000..62856f6
--- /dev/null
+++ b/Model/Plugin/PluginSyncCommandOptions.cs
@@ -0,0 +1,8 @@
+namespace XrmSync.Model.Plugin;
+
+// Command-specific options that can be populated from CLI or profile
+public record PluginSyncCommandOptions(string AssemblyPath, string SolutionName)
+{
+	public static PluginSyncCommandOptions Empty => new(string.Empty, string.Empty);
+}
+
diff --git a/Model/Webresource/WebresourceSyncCommandOptions.cs b/Model/Webresource/WebresourceSyncCommandOptions.cs
new file mode 100644
index 0000000..e0e80b4
--- /dev/null
+++ b/Model/Webresource/WebresourceSyncCommandOptions.cs
@@ -0,0 +1,7 @@
+namespace XrmSync.Model.Webresource;
+
+public record WebresourceSyncCommandOptions(string FolderPath, string SolutionName, List<string>? FileExtensions = null)
+{
+	public static WebresourceSyncCommandOptions Empty => new(string.Empty, string.Empty);
+}
+
diff --git a/Model/XrmSyncOptions.cs b/Model/XrmSyncOptions.cs
index 52b361e..f381c1d 100644
--- a/Model/XrmSyncOptions.cs
+++ b/Model/XrmSyncOptions.cs
@@ -92,27 +92,6 @@ public record WebresourceSyncItem(string FolderPath, List<string>? FileExtension
 	public override string SyncType => TypeName;
 }
 
-public record SharedOptions(string? ProfileName)
-{
-	public static SharedOptions Empty => new((string?)null);
-}
-
-// Command-specific options that can be populated from CLI or profile
-public record PluginSyncCommandOptions(string AssemblyPath, string SolutionName)
-{
-	public static PluginSyncCommandOptions Empty => new(string.Empty, string.Empty);
-}
-
-public record PluginAnalysisCommandOptions(string AssemblyPath, string PublisherPrefix, bool PrettyPrint)
-{
-	public static PluginAnalysisCommandOptions Empty => new(string.Empty, "new", false);
-}
-
-public record WebresourceSyncCommandOptions(string FolderPath, string SolutionName, List<string>? FileExtensions = null)
-{
-	public static WebresourceSyncCommandOptions Empty => new(string.Empty, string.Empty);
-}
-
 public enum IdentityOperation
 {
 	Remove,
@@ -128,12 +107,3 @@ public record IdentitySyncItem(IdentityOperation? Operation = null, string Assem
 	public override string SyncType => Operation.HasValue ? $"{TypeName} ({Operation})" : TypeName;
 }
 
-public record IdentityCommandOptions(IdentityOperation Operation, string AssemblyPath, string SolutionName, string ClientId, string TenantId)
-{
-	public static IdentityCommandOptions Empty => new(IdentityOperation.Remove, string.Empty, string.Empty, string.Empty, string.Empty);
-}
-
-public record ExecutionModeOptions(bool DryRun)
-{
-	public static ExecutionModeOptions Empty => new(false);
-}
diff --git a/SyncService/Difference/PrintService.cs b/SyncService/Difference/PrintService.cs
index eb12442..179c084 100644
--- a/SyncService/Difference/PrintService.cs
+++ b/SyncService/Difference/PrintService.cs
@@ -8,10 +8,10 @@ namespace XrmSync.SyncService.Difference;
 
 internal class PrintService(
 	ILogger<PrintService> log,
-	IOptions<ExecutionModeOptions> configuration
+	IOptions<ExecutionContext> configuration
 	) : IPrintService
 {
-	private readonly LogLevel LogLevel = configuration.Value.DryRun ? LogLevel.Information : LogLevel.Debug;
+	private readonly LogLevel LogLevel = configuration.Value.DryRun == true ? LogLevel.Information : LogLevel.Debug;
 
 	public void Print<TEntity>(Difference<TEntity> differences, string title, Func<TEntity, string> namePicker)
 		where TEntity : EntityBase
diff --git a/SyncService/GlobalUsings.cs b/SyncService/GlobalUsings.cs
new file mode 100644
index 0000000..23e2014
--- /dev/null
+++ b/SyncService/GlobalUsings.cs
@@ -0,0 +1 @@
+global using ExecutionContext = XrmSync.Model.ExecutionContext;
diff --git a/SyncService/IdentitySyncService.cs b/SyncService/IdentitySyncService.cs
index 235b7ce..dad6a32 100644
--- a/SyncService/IdentitySyncService.cs
+++ b/SyncService/IdentitySyncService.cs
@@ -3,7 +3,7 @@
 using XrmSync.Dataverse.Interfaces;
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
-using XrmSync.SyncService.Difference;
+using XrmSync.Model.Identity;
 
 namespace XrmSync.SyncService;
 
diff --git a/SyncService/WebresourceSyncService.cs b/SyncService/WebresourceSyncService.cs
index 544a842..260191b 100644
--- a/SyncService/WebresourceSyncService.cs
+++ b/SyncService/WebresourceSyncService.cs
@@ -2,10 +2,8 @@
 using Microsoft.Extensions.Options;
 using XrmSync.Analyzer.Reader;
 using XrmSync.Dataverse.Interfaces;
-using XrmSync.Model;
 using XrmSync.Model.Exceptions;
 using XrmSync.Model.Webresource;
-using XrmSync.SyncService.Difference;
 using XrmSync.SyncService.Exceptions;
 using XrmSync.SyncService.Validation;
 
diff --git a/Tests.Integration/GlobalUsings.cs b/Tests.Integration/GlobalUsings.cs
new file mode 100644
index 0000000..23e2014
--- /dev/null
+++ b/Tests.Integration/GlobalUsings.cs
@@ -0,0 +1 @@
+global using ExecutionContext = XrmSync.Model.ExecutionContext;
diff --git a/Tests.Integration/Infrastructure/TestBase.cs b/Tests.Integration/Infrastructure/TestBase.cs
index f73f73d..8f50b13 100644
--- a/Tests.Integration/Infrastructure/TestBase.cs
+++ b/Tests.Integration/Infrastructure/TestBase.cs
@@ -6,7 +6,8 @@
 using NSubstitute;
 using XrmSync.Dataverse.Extensions;
 using XrmSync.Dataverse.Interfaces;
-using XrmSync.Model;
+using XrmSync.Model.Plugin;
+using XrmSync.Model.Webresource;
 
 namespace Tests.Integration.Infrastructure;
 
@@ -70,7 +71,7 @@ private IServiceCollection BuildBaseServices()
 		services.AddSingleton(ServiceProvider);
 
 		// Configure execution options (not dry run for tests)
-		services.AddSingleton(Options.Create(new ExecutionModeOptions(DryRun: false)));
+		services.AddSingleton(Options.Create(new ExecutionContext(null, false, null, null, null)));
 
 		// Reuse all reader/writer registrations from production code
 		services.AddDataverseServices();
diff --git a/Tests/Config/ConfigValidateCommandTests.cs b/Tests/Config/ConfigValidateCommandTests.cs
index aae764d..2feed19 100644
--- a/Tests/Config/ConfigValidateCommandTests.cs
+++ b/Tests/Config/ConfigValidateCommandTests.cs
@@ -70,7 +70,7 @@ public async Task ConfigValidationOutputWithValidConfigurationOutputsSuccessfull
 		{
 			var configReader = new TestConfigReader(tempFile);
 			var configuration = configReader.GetConfiguration();
-			var sharedOptions = Options.Create(SharedOptions.Empty);
+			var sharedOptions = Options.Create(ExecutionContext.Empty);
 			var builder = new XrmSyncConfigurationBuilder(configuration);
 			var config = builder.Build();
 			var configOptions = Options.Create(config);
@@ -129,7 +129,7 @@ public async Task ConfigValidationOutputWithMultipleConfigsListsAllConfiguration
 		{
 			var configReader = new TestConfigReader(tempFile);
 			var configuration = configReader.GetConfiguration();
-			var sharedOptions = Options.Create(SharedOptions.Empty);
+			var sharedOptions = Options.Create(ExecutionContext.Empty);
 			var builder = new XrmSyncConfigurationBuilder(configuration);
 			var config = builder.Build();
 			var configOptions = Options.Create(config);
@@ -162,7 +162,7 @@ public async Task ConfigValidationOutputWithNoConfigurationHandlesGracefully()
 		{
 			var configReader = new TestConfigReader(tempFile);
 			var configuration = configReader.GetConfiguration();
-			var sharedOptions = Options.Create(SharedOptions.Empty);
+			var sharedOptions = Options.Create(ExecutionContext.Empty);
 			var builder = new XrmSyncConfigurationBuilder(configuration);
 			var config = builder.Build();
 			var configOptions = Options.Create(config);
@@ -186,7 +186,7 @@ public async Task OutputAllValidationResultsWithNoProfilesHandlesGracefully()
 		var configuration = new ConfigurationBuilder().Build();
 		var config = XrmSyncConfiguration.Empty;
 		var configOptions = Options.Create(config);
-		var sharedOptions = Options.Create(SharedOptions.Empty);
+		var sharedOptions = Options.Create(ExecutionContext.Empty);
 
 		var output = new ConfigValidationOutput(configuration, configOptions, sharedOptions);
 
@@ -210,7 +210,7 @@ public async Task OutputAllValidationResultsWithSingleProfileOutputsValidationRe
 			]
 		);
 		var configOptions = Options.Create(config);
-		var sharedOptions = Options.Create(SharedOptions.Empty);
+		var sharedOptions = Options.Create(ExecutionContext.Empty);
 
 		var output = new ConfigValidationOutput(configuration, configOptions, sharedOptions);
 
@@ -235,7 +235,7 @@ public async Task OutputAllValidationResultsWithMultipleProfilesOutputsAllProfil
 			]
 		);
 		var configOptions = Options.Create(config);
-		var sharedOptions = Options.Create(SharedOptions.Empty);
+		var sharedOptions = Options.Create(ExecutionContext.Empty);
 
 		var output = new ConfigValidationOutput(configuration, configOptions, sharedOptions);
 
@@ -260,7 +260,7 @@ public async Task OutputAllValidationResultsWithInvalidProfileReportsFailure()
 			]
 		);
 		var configOptions = Options.Create(config);
-		var sharedOptions = Options.Create(SharedOptions.Empty);
+		var sharedOptions = Options.Create(ExecutionContext.Empty);
 
 		var output = new ConfigValidationOutput(configuration, configOptions, sharedOptions);
 
diff --git a/Tests/Config/OptionsValidationTests.cs b/Tests/Config/OptionsValidationTests.cs
index 190b593..aabd31b 100644
--- a/Tests/Config/OptionsValidationTests.cs
+++ b/Tests/Config/OptionsValidationTests.cs
@@ -7,8 +7,8 @@ namespace Tests.Config;
 
 public class OptionsValidationTests
 {
-	private static SharedOptions CreateSharedOptions(string profileName = "default") =>
-		new SharedOptions(profileName);
+	private static ExecutionContext CreateSharedOptions(string profileName = "default") =>
+		new ExecutionContext(null, null, null, null, profileName);
 
 	[Fact]
 	public void PluginSyncValidatorValidOptionsPassesValidation()
@@ -767,7 +767,7 @@ public void ValidatorNoProfilesAndNoProfileNamePassesValidation()
 		// Act & Assert - Should not throw (CLI mode, no profile validation needed)
 		var validator = new XrmSyncConfigurationValidator(
 			Options.Create(config),
-			Options.Create(new SharedOptions(null)));
+			Options.Create(new ExecutionContext(null, null, null, null, null)));
 		validator.Validate(ConfigurationScope.PluginSync);
 	}
 
diff --git a/Tests/CustomApis/DifferenceCalculatorCustomApiTests.cs b/Tests/CustomApis/DifferenceCalculatorCustomApiTests.cs
index cb34712..853437e 100644
--- a/Tests/CustomApis/DifferenceCalculatorCustomApiTests.cs
+++ b/Tests/CustomApis/DifferenceCalculatorCustomApiTests.cs
@@ -20,7 +20,7 @@ public DifferenceCalculatorCustomApiTests()
 	{
 		var logger = new LoggerFactory().CreateLogger<PrintService>();
 		var description = new Description();
-		var options = new ExecutionModeOptions(true);
+		var options = new ExecutionContext(null, true, null, null, null);
 		differenceCalculator = new DifferenceCalculator(
 			new PluginDefinitionComparer(),
 			new PluginStepComparer(),
diff --git a/Tests/GlobalUsings.cs b/Tests/GlobalUsings.cs
new file mode 100644
index 0000000..23e2014
--- /dev/null
+++ b/Tests/GlobalUsings.cs
@@ -0,0 +1 @@
+global using ExecutionContext = XrmSync.Model.ExecutionContext;
diff --git a/Tests/ManagedIdentity/IdentitySyncServiceTests.cs b/Tests/ManagedIdentity/IdentitySyncServiceTests.cs
index c179d6d..1e4031d 100644
--- a/Tests/ManagedIdentity/IdentitySyncServiceTests.cs
+++ b/Tests/ManagedIdentity/IdentitySyncServiceTests.cs
@@ -5,6 +5,7 @@
 using XrmSync.Dataverse.Interfaces;
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
+using XrmSync.Model.Identity;
 using XrmSync.SyncService;
 
 namespace Tests.ManagedIdentity;
diff --git a/Tests/Plugins/AssemblyReaderTests.cs b/Tests/Plugins/AssemblyReaderTests.cs
index d350698..8af27b1 100644
--- a/Tests/Plugins/AssemblyReaderTests.cs
+++ b/Tests/Plugins/AssemblyReaderTests.cs
@@ -16,7 +16,7 @@ public class AssemblyReaderTests
 
 	public AssemblyReaderTests()
 	{
-		assemblyReader = new LocalReader(logger, Options.Create(SharedOptions.Empty));
+		assemblyReader = new LocalReader(logger, Options.Create(ExecutionContext.Empty));
 	}
 
 	[Fact]
diff --git a/Tests/Plugins/DifferenceUtilityTests.cs b/Tests/Plugins/DifferenceUtilityTests.cs
index 225f40b..f16c1cb 100644
--- a/Tests/Plugins/DifferenceUtilityTests.cs
+++ b/Tests/Plugins/DifferenceUtilityTests.cs
@@ -21,7 +21,7 @@ public DifferenceUtilityTests()
 	{
 		var logger = new LoggerFactory().CreateLogger<PrintService>();
 		var description = new Description();
-		var options = new ExecutionModeOptions(true);
+		var options = new ExecutionContext(null, true, null, null, null);
 		differenceUtility = new DifferenceCalculator(
 			new PluginDefinitionComparer(),
 			new PluginStepComparer(),
diff --git a/Tests/Webresources/WebresourceSyncServiceTests.cs b/Tests/Webresources/WebresourceSyncServiceTests.cs
index 102bb5c..9c9b790 100644
--- a/Tests/Webresources/WebresourceSyncServiceTests.cs
+++ b/Tests/Webresources/WebresourceSyncServiceTests.cs
@@ -3,7 +3,6 @@
 using NSubstitute;
 using XrmSync.Analyzer.Reader;
 using XrmSync.Dataverse.Interfaces;
-using XrmSync.Model;
 using XrmSync.Model.Webresource;
 using XrmSync.SyncService;
 using XrmSync.SyncService.Difference;
diff --git a/Tests/Webresources/WebresourceWriterTests.cs b/Tests/Webresources/WebresourceWriterTests.cs
index b3463ce..9e22e0f 100644
--- a/Tests/Webresources/WebresourceWriterTests.cs
+++ b/Tests/Webresources/WebresourceWriterTests.cs
@@ -3,7 +3,6 @@
 using XrmSync.Dataverse;
 using XrmSync.Dataverse.Context;
 using XrmSync.Dataverse.Interfaces;
-using XrmSync.Model;
 using XrmSync.Model.Webresource;
 
 namespace Tests.Webresources;
diff --git a/XrmSync/Commands/CommandOptions.cs b/XrmSync/Commands/CommandOptions.cs
new file mode 100644
index 0000000..f0849c3
--- /dev/null
+++ b/XrmSync/Commands/CommandOptions.cs
@@ -0,0 +1,28 @@
+using Microsoft.Extensions.Logging;
+using System.CommandLine;
+using XrmSync.Constants;
+using XrmSync.Model;
+
+namespace XrmSync.Commands;
+
+/// <summary>
+/// Single source of truth for all shared CLI option instances.
+/// Shared between the root command (as profile overrides) and sub-commands (as primary inputs).
+/// All string options are nullable: required-ness is validated programmatically since any option
+/// may be satisfied by a profile rather than a CLI argument.
+/// </summary>
+internal static class CommandOptions
+{
+	public static readonly Option<string?> Assembly = CliOptions.Assembly.CreateOption<string?>();
+	public static readonly Option<string?> Solution = CliOptions.Solution.CreateOption<string?>();
+	public static readonly Option<string?> Folder = CliOptions.Webresource.CreateOption<string?>();
+	public static readonly Option<string[]?> FileExtensions = CliOptions.FileExtensions.CreateOption<string[]?>();
+	public static readonly Option<string?> Prefix = CliOptions.Analysis.Prefix.CreateOption<string?>();
+	public static readonly Option<IdentityOperation?> Operation = CliOptions.ManagedIdentity.Operation.CreateOption<IdentityOperation?>();
+	public static readonly Option<string?> ClientId = CliOptions.ManagedIdentity.ClientId.CreateOption<string?>();
+	public static readonly Option<string?> TenantId = CliOptions.ManagedIdentity.TenantId.CreateOption<string?>();
+	public static readonly Option<bool?> DryRun = CliOptions.Execution.DryRun.CreateOption<bool?>();
+	public static readonly Option<LogLevel?> LogLevel = CliOptions.Logging.LogLevel.CreateOption<LogLevel?>();
+	public static readonly Option<bool?> CiMode = CliOptions.Logging.CiMode.CreateOption<bool?>();
+	public static readonly Option<string?> Profile = CliOptions.Config.Profile.CreateOption<string?>();
+}
diff --git a/XrmSync/Commands/ConfigCommand.cs b/XrmSync/Commands/ConfigCommand.cs
index b57bf05..8b15660 100644
--- a/XrmSync/Commands/ConfigCommand.cs
+++ b/XrmSync/Commands/ConfigCommand.cs
@@ -17,6 +17,6 @@ public ConfigCommand() : base("config", "Configuration management commands")
 	/// <summary>
 	/// Config command does not handle profile sync items.
 	/// </summary>
-	public Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	public Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct)
 		=> Task.FromResult<int?>(null);
 }
diff --git a/XrmSync/Commands/ConfigValidateCommand.cs b/XrmSync/Commands/ConfigValidateCommand.cs
index 36a6647..edbec5c 100644
--- a/XrmSync/Commands/ConfigValidateCommand.cs
+++ b/XrmSync/Commands/ConfigValidateCommand.cs
@@ -20,12 +20,11 @@ public ConfigValidateCommand() : base("validate", "Validate configuration from a
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
-		var sharedOptions = GetSharedOptionValues(parseResult);
 		var all = parseResult.GetValue(AllOption);
 
 		// Build service provider - no overrides, just validate what's in the config
 		var serviceProvider = GetConfigValidateServices()
-			.AddXrmSyncConfiguration(sharedOptions)
+			.AddXrmSyncConfiguration(new ExecutionContext(null, null, null, null, parseResult.GetValue(CommandOptions.Profile)))
 			.AddOptions(baseOptions => baseOptions) // No overrides
 			.BuildServiceProvider();
 
diff --git a/XrmSync/Commands/IXrmSyncCommand.cs b/XrmSync/Commands/IXrmSyncCommand.cs
index e23bf65..7478b0b 100644
--- a/XrmSync/Commands/IXrmSyncCommand.cs
+++ b/XrmSync/Commands/IXrmSyncCommand.cs
@@ -18,5 +18,5 @@ internal interface IXrmSyncCommand
 	/// and root-level execution context. Returns null when this command does not
 	/// handle the given sync item type; returns an exit code otherwise.
 	/// </summary>
-	Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct);
+	Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct);
 }
diff --git a/XrmSync/Commands/IdentityCommand.cs b/XrmSync/Commands/IdentityCommand.cs
index 588ecaa..de28ac1 100644
--- a/XrmSync/Commands/IdentityCommand.cs
+++ b/XrmSync/Commands/IdentityCommand.cs
@@ -1,11 +1,10 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using System.CommandLine;
-using XrmSync.Constants;
 using XrmSync.Extensions;
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
+using XrmSync.Model.Identity;
 using XrmSync.Options;
 using XrmSync.SyncService.Extensions;
 using MSOptions = Microsoft.Extensions.Options.Options;
@@ -14,22 +13,12 @@ namespace XrmSync.Commands;
 
 internal class IdentityCommand : XrmSyncCommandBase
 {
-	private readonly Option<IdentityOperation?> operation;
-	private readonly Option<string> assemblyFile;
-	private readonly Option<string> clientId;
-	private readonly Option<string> tenantId;
-
 	public IdentityCommand() : base("identity", "Manage the managed identity linked to a plugin assembly")
 	{
-		operation = CliOptions.ManagedIdentity.Operation.CreateOption<IdentityOperation?>();
-		assemblyFile = CliOptions.Assembly.CreateOption<string>();
-		clientId = CliOptions.ManagedIdentity.ClientId.CreateOption<string>();
-		tenantId = CliOptions.ManagedIdentity.TenantId.CreateOption<string>();
-
-		Add(operation);
-		Add(assemblyFile);
-		Add(clientId);
-		Add(tenantId);
+		Add(CommandOptions.Operation);
+		Add(CommandOptions.Assembly);
+		Add(CommandOptions.ClientId);
+		Add(CommandOptions.TenantId);
 
 		AddSharedOptions();
 		AddSyncOptions();
@@ -37,7 +26,7 @@ public IdentityCommand() : base("identity", "Manage the managed identity linked
 		SetAction(ExecuteAsync);
 	}
 
-	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct)
 	{
 		if (syncItem is not IdentitySyncItem identity) return null;
 
@@ -50,7 +39,7 @@ public IdentityCommand() : base("identity", "Manage the managed identity linked
 		return await RunCore(
 			identity.Operation.Value,
 			identity.AssemblyPath,
-			ctx.SolutionName,
+			ctx.SolutionName ?? string.Empty,
 			identity.ClientId,
 			identity.TenantId,
 			ctx.DryRun,
@@ -62,12 +51,15 @@ public IdentityCommand() : base("identity", "Manage the managed identity linked
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
-		var operationValue = parseResult.GetValue(operation);
-		var assemblyPath = parseResult.GetValue(assemblyFile);
-		var clientIdValue = parseResult.GetValue(clientId);
-		var tenantIdValue = parseResult.GetValue(tenantId);
-		var (solutionName, dryRun, logLevel, ciMode) = GetSyncSharedOptionValues(parseResult);
-		var sharedOptions = GetSharedOptionValues(parseResult);
+		var operationValue = parseResult.GetValue(CommandOptions.Operation);
+		var assemblyPath = parseResult.GetValue(CommandOptions.Assembly);
+		var clientIdValue = parseResult.GetValue(CommandOptions.ClientId);
+		var tenantIdValue = parseResult.GetValue(CommandOptions.TenantId);
+		var solutionName = parseResult.GetValue(CommandOptions.Solution);
+		var dryRun = parseResult.GetValue(CommandOptions.DryRun);
+		var logLevel = parseResult.GetValue(CommandOptions.LogLevel);
+		var ciMode = parseResult.GetValue(CommandOptions.CiMode);
+		var profileName = parseResult.GetValue(CommandOptions.Profile);
 
 		// Resolve final options eagerly (CLI + profile merge)
 		IdentityOperation? finalOperation;
@@ -76,7 +68,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		string finalClientId;
 		string finalTenantId;
 
-		if (sharedOptions.ProfileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(solutionName))
+		if (profileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(solutionName))
 		{
 			// Standalone mode: all required values supplied via CLI
 			finalOperation = operationValue;
@@ -89,7 +81,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		{
 			// Profile mode: merge profile values with CLI overrides
 			ProfileConfiguration? profile;
-			try { profile = LoadProfile(sharedOptions.ProfileName); }
+			try { profile = LoadProfileAndConfig(profileName).Profile; }
 			catch (XrmSyncException ex) { Console.Error.WriteLine(ex.Message); return E_ERROR; }
 
 			if (profile == null)
@@ -131,7 +123,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		if (errors.Count > 0)
 			return ValidationError($"identity --operation {finalOperation?.ToString() ?? "<none>"}", errors);
 
-		return await RunCore(finalOperation!.Value, finalAssemblyPath, finalSolutionName, finalClientId, finalTenantId, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
+		return await RunCore(finalOperation!.Value, finalAssemblyPath, finalSolutionName, finalClientId, finalTenantId, dryRun, ciMode, logLevel, profileName, cancellationToken);
 	}
 
 	private async Task<int> RunCore(
@@ -162,7 +154,7 @@ private async Task<int> RunCore(
 
 		var serviceProvider = new ServiceCollection()
 			.AddIdentityService()
-			.AddXrmSyncConfiguration(new SharedOptions(profileName))
+			.AddXrmSyncConfiguration(new ExecutionContext(null, null, null, null, profileName))
 			.AddOptions(
 				baseOptions => baseOptions with
 				{
@@ -171,11 +163,6 @@ private async Task<int> RunCore(
 					DryRun = dryRun ?? baseOptions.DryRun
 				})
 			.AddSingleton(MSOptions.Create(new IdentityCommandOptions(operation, assemblyPath, solutionName, clientId, tenantId)))
-			.AddSingleton(sp =>
-			{
-				var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
-				return MSOptions.Create(new ExecutionModeOptions(config.DryRun));
-			})
 			.AddLogger()
 			.BuildServiceProvider();
 
diff --git a/XrmSync/Commands/PluginAnalyzeCommand.cs b/XrmSync/Commands/PluginAnalyzeCommand.cs
index 3544fbc..e7b30f4 100644
--- a/XrmSync/Commands/PluginAnalyzeCommand.cs
+++ b/XrmSync/Commands/PluginAnalyzeCommand.cs
@@ -7,6 +7,7 @@
 using XrmSync.Constants;
 using XrmSync.Extensions;
 using XrmSync.Model;
+using XrmSync.Model.Plugin;
 using XrmSync.Model.Exceptions;
 using XrmSync.Options;
 using MSOptions = Microsoft.Extensions.Options.Options;
@@ -15,25 +16,19 @@ namespace XrmSync.Commands;
 
 internal class PluginAnalyzeCommand : XrmSyncCommandBase
 {
-	private readonly Option<string> assemblyFile;
-	private readonly Option<string> prefix;
-	private readonly Option<bool> prettyPrint;
+	private static readonly Option<bool> PrettyPrint = CliOptions.Analysis.PrettyPrint.CreateOption<bool>();
 
 	public PluginAnalyzeCommand() : base("analyze", "Analyze a plugin assembly and output info as JSON")
 	{
-		assemblyFile = CliOptions.Assembly.CreateOption<string>();
-		prefix = CliOptions.Analysis.Prefix.CreateOption<string>();
-		prettyPrint = CliOptions.Analysis.PrettyPrint.CreateOption<bool>();
-
-		Add(assemblyFile);
-		Add(prefix);
-		Add(prettyPrint);
+		Add(CommandOptions.Assembly);
+		Add(CommandOptions.Prefix);
+		Add(PrettyPrint);
 		AddSharedOptions();
 
 		SetAction(ExecuteAsync);
 	}
 
-	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct)
 	{
 		if (syncItem is not PluginAnalysisSyncItem analysis) return null;
 		return await RunCore(analysis.AssemblyPath, analysis.PublisherPrefix, analysis.PrettyPrint, ctx.ProfileName, ct);
@@ -41,17 +36,17 @@ public PluginAnalyzeCommand() : base("analyze", "Analyze a plugin assembly and o
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
-		var assemblyPath = parseResult.GetValue(assemblyFile);
-		var publisherPrefix = parseResult.GetValue(prefix);
-		var prettyPrintValue = parseResult.GetValue(this.prettyPrint);
-		var sharedOptions = GetSharedOptionValues(parseResult);
+		var assemblyPath = parseResult.GetValue(CommandOptions.Assembly);
+		var publisherPrefix = parseResult.GetValue(CommandOptions.Prefix);
+		var prettyPrintValue = parseResult.GetValue(PrettyPrint);
+		var profileName = parseResult.GetValue(CommandOptions.Profile);
 
 		// Resolve final options eagerly (CLI + profile merge)
 		string finalAssemblyPath;
 		string finalPublisherPrefix;
 		bool finalPrettyPrint;
 
-		if (sharedOptions.ProfileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(publisherPrefix))
+		if (profileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(publisherPrefix))
 		{
 			// Standalone mode: all required values supplied via CLI
 			finalAssemblyPath = assemblyPath;
@@ -62,7 +57,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		{
 			// Profile mode: merge profile values with CLI overrides
 			ProfileConfiguration? profile;
-			try { profile = LoadProfile(sharedOptions.ProfileName); }
+			try { profile = LoadProfileAndConfig(profileName).Profile; }
 			catch (XrmSyncException ex) { Console.Error.WriteLine(ex.Message); return E_ERROR; }
 
 			if (profile == null)
@@ -79,7 +74,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			finalPrettyPrint = prettyPrintValue || (pluginAnalysisItem?.PrettyPrint ?? false);
 		}
 
-		return await RunCore(finalAssemblyPath, finalPublisherPrefix, finalPrettyPrint, sharedOptions.ProfileName, cancellationToken);
+		return await RunCore(finalAssemblyPath, finalPublisherPrefix, finalPrettyPrint, profileName, cancellationToken);
 	}
 
 	private async Task<int> RunCore(
@@ -96,7 +91,7 @@ private async Task<int> RunCore(
 			return ValidationError("analyze", errors);
 
 		var serviceProvider = GetAnalyzerServices()
-			.AddXrmSyncConfiguration(new SharedOptions(profileName))
+			.AddXrmSyncConfiguration(new ExecutionContext(null, null, null, null, profileName))
 			.AddOptions(baseOptions => baseOptions)
 			.AddSingleton(MSOptions.Create(new PluginAnalysisCommandOptions(assemblyPath, publisherPrefix, prettyPrintValue)))
 			.AddLogger()
diff --git a/XrmSync/Commands/PluginSyncCommand.cs b/XrmSync/Commands/PluginSyncCommand.cs
index 0b3a3c9..5913eab 100644
--- a/XrmSync/Commands/PluginSyncCommand.cs
+++ b/XrmSync/Commands/PluginSyncCommand.cs
@@ -1,10 +1,9 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using System.CommandLine;
-using XrmSync.Constants;
 using XrmSync.Extensions;
 using XrmSync.Model;
+using XrmSync.Model.Plugin;
 using XrmSync.Options;
 using XrmSync.SyncService.Extensions;
 using MSOptions = Microsoft.Extensions.Options.Options;
@@ -13,13 +12,9 @@ namespace XrmSync.Commands;
 
 internal class PluginSyncCommand : XrmSyncCommandBase
 {
-	private readonly Option<string> assemblyFile;
-
 	public PluginSyncCommand() : base("plugins", "Synchronize plugins in a plugin assembly with Dataverse")
 	{
-		assemblyFile = CliOptions.Assembly.CreateOption<string>();
-
-		Add(assemblyFile);
+		Add(CommandOptions.Assembly);
 
 		AddSharedOptions();
 		AddSyncOptions();
@@ -27,23 +22,26 @@ public PluginSyncCommand() : base("plugins", "Synchronize plugins in a plugin as
 		SetAction(ExecuteAsync);
 	}
 
-	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct)
 	{
 		if (syncItem is not PluginSyncItem plugin) return null;
-		return await RunCore(plugin.AssemblyPath, ctx.SolutionName, ctx.DryRun, ctx.CiMode, ctx.LogLevel, ctx.ProfileName, ct);
+		return await RunCore(plugin.AssemblyPath, ctx.SolutionName ?? string.Empty, ctx.DryRun, ctx.CiMode, ctx.LogLevel, ctx.ProfileName, ct);
 	}
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
-		var assemblyPath = parseResult.GetValue(assemblyFile);
-		var (solutionName, dryRun, logLevel, ciMode) = GetSyncSharedOptionValues(parseResult);
-		var sharedOptions = GetSharedOptionValues(parseResult);
+		var assemblyPath = parseResult.GetValue(CommandOptions.Assembly);
+		var solutionName = parseResult.GetValue(CommandOptions.Solution);
+		var dryRun = parseResult.GetValue(CommandOptions.DryRun);
+		var logLevel = parseResult.GetValue(CommandOptions.LogLevel);
+		var ciMode = parseResult.GetValue(CommandOptions.CiMode);
+		var profileName = parseResult.GetValue(CommandOptions.Profile);
 
 		// Resolve final options eagerly (CLI + profile merge)
 		string finalAssemblyPath;
 		string finalSolutionName;
 
-		if (sharedOptions.ProfileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(solutionName))
+		if (profileName == null && !string.IsNullOrWhiteSpace(assemblyPath) && !string.IsNullOrWhiteSpace(solutionName))
 		{
 			// Standalone mode: all required values supplied via CLI
 			finalAssemblyPath = assemblyPath;
@@ -53,7 +51,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 		{
 			// Profile mode: merge profile values with CLI overrides
 			ProfileConfiguration? profile;
-			try { profile = LoadProfile(sharedOptions.ProfileName); }
+			try { profile = LoadProfileAndConfig(profileName).Profile; }
 			catch (Model.Exceptions.XrmSyncException ex) { Console.Error.WriteLine(ex.Message); return E_ERROR; }
 
 			if (profile == null)
@@ -69,7 +67,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			finalSolutionName = solutionName.GetValueOrDefault(profile.SolutionName);
 		}
 
-		return await RunCore(finalAssemblyPath, finalSolutionName, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
+		return await RunCore(finalAssemblyPath, finalSolutionName, dryRun, ciMode, logLevel, profileName, cancellationToken);
 	}
 
 	private async Task<int> RunCore(
@@ -88,7 +86,7 @@ private async Task<int> RunCore(
 			return ValidationError("plugins", errors);
 
 		var serviceProvider = GetPluginSyncServices()
-			.AddXrmSyncConfiguration(new SharedOptions(profileName))
+			.AddXrmSyncConfiguration(new ExecutionContext(null, null, null, null, profileName))
 			.AddOptions(
 				baseOptions => baseOptions with
 				{
@@ -97,11 +95,6 @@ private async Task<int> RunCore(
 					DryRun = dryRun ?? baseOptions.DryRun
 				})
 			.AddSingleton(MSOptions.Create(new PluginSyncCommandOptions(assemblyPath, solutionName)))
-			.AddSingleton(sp =>
-			{
-				var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
-				return MSOptions.Create(new ExecutionModeOptions(config.DryRun));
-			})
 			.AddLogger()
 			.BuildServiceProvider();
 
diff --git a/XrmSync/Commands/ProfileExecutionContext.cs b/XrmSync/Commands/ProfileExecutionContext.cs
deleted file mode 100644
index c7d7f24..0000000
--- a/XrmSync/Commands/ProfileExecutionContext.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using Microsoft.Extensions.Logging;
-
-namespace XrmSync.Commands;
-
-/// <summary>
-/// Carries the already-resolved execution values the root command passes to sub-commands
-/// when dispatching profile sync items.
-/// </summary>
-internal record ProfileExecutionContext(
-	string SolutionName,
-	bool DryRun,
-	bool CiMode,
-	LogLevel LogLevel,
-	string? ProfileName);
diff --git a/XrmSync/Commands/WebresourceSyncCommand.cs b/XrmSync/Commands/WebresourceSyncCommand.cs
index 7feb472..11b853c 100644
--- a/XrmSync/Commands/WebresourceSyncCommand.cs
+++ b/XrmSync/Commands/WebresourceSyncCommand.cs
@@ -1,10 +1,9 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using System.CommandLine;
-using XrmSync.Constants;
 using XrmSync.Extensions;
 using XrmSync.Model;
+using XrmSync.Model.Webresource;
 using XrmSync.Options;
 using XrmSync.SyncService.Extensions;
 using MSOptions = Microsoft.Extensions.Options.Options;
@@ -13,16 +12,10 @@ namespace XrmSync.Commands
 {
 	internal class WebresourceSyncCommand : XrmSyncCommandBase
 	{
-		private readonly Option<string> webresourceRoot;
-		private readonly Option<string[]> fileExtensions;
-
 		public WebresourceSyncCommand() : base("webresources", "Synchronize webresources from a local folder with Dataverse")
 		{
-			webresourceRoot = CliOptions.Webresource.CreateOption<string>();
-			fileExtensions = CliOptions.FileExtensions.CreateOption<string[]>();
-
-			Add(webresourceRoot);
-			Add(fileExtensions);
+			Add(CommandOptions.Folder);
+			Add(CommandOptions.FileExtensions);
 
 			AddSharedOptions();
 			AddSyncOptions();
@@ -30,25 +23,28 @@ public WebresourceSyncCommand() : base("webresources", "Synchronize webresources
 			SetAction(ExecuteAsync);
 		}
 
-		public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+		public override async Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct)
 		{
 			if (syncItem is not WebresourceSyncItem webresource) return null;
-			return await RunCore(webresource.FolderPath, ctx.SolutionName, webresource.FileExtensions, ctx.DryRun, ctx.CiMode, ctx.LogLevel, ctx.ProfileName, ct);
+			return await RunCore(webresource.FolderPath, ctx.SolutionName ?? string.Empty, webresource.FileExtensions, ctx.DryRun, ctx.CiMode, ctx.LogLevel, ctx.ProfileName, ct);
 		}
 
 		private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 		{
-			var folderPath = parseResult.GetValue(webresourceRoot);
-			var extensionsValue = parseResult.GetValue(fileExtensions);
-			var (solutionName, dryRun, logLevel, ciMode) = GetSyncSharedOptionValues(parseResult);
-			var sharedOptions = GetSharedOptionValues(parseResult);
+			var folderPath = parseResult.GetValue(CommandOptions.Folder);
+			var extensionsValue = parseResult.GetValue(CommandOptions.FileExtensions);
+			var solutionName = parseResult.GetValue(CommandOptions.Solution);
+			var dryRun = parseResult.GetValue(CommandOptions.DryRun);
+			var logLevel = parseResult.GetValue(CommandOptions.LogLevel);
+			var ciMode = parseResult.GetValue(CommandOptions.CiMode);
+			var profileName = parseResult.GetValue(CommandOptions.Profile);
 
 			// Resolve final options eagerly (CLI + profile merge)
 			string finalFolderPath;
 			string finalSolutionName;
 			List<string>? finalExtensions;
 
-			if (sharedOptions.ProfileName == null && !string.IsNullOrWhiteSpace(folderPath) && !string.IsNullOrWhiteSpace(solutionName))
+			if (profileName == null && !string.IsNullOrWhiteSpace(folderPath) && !string.IsNullOrWhiteSpace(solutionName))
 			{
 				// Standalone mode: all required values supplied via CLI
 				finalFolderPath = folderPath;
@@ -59,7 +55,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			{
 				// Profile mode: merge profile values with CLI overrides
 				ProfileConfiguration? profile;
-				try { profile = LoadProfile(sharedOptions.ProfileName); }
+				try { profile = LoadProfileAndConfig(profileName).Profile; }
 				catch (Model.Exceptions.XrmSyncException ex) { Console.Error.WriteLine(ex.Message); return E_ERROR; }
 
 				if (profile == null)
@@ -76,7 +72,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 				finalExtensions = extensionsValue is { Length: > 0 } ? [.. extensionsValue] : webresourceSyncItem?.FileExtensions;
 			}
 
-			return await RunCore(finalFolderPath, finalSolutionName, finalExtensions, dryRun, ciMode, logLevel, sharedOptions.ProfileName, cancellationToken);
+			return await RunCore(finalFolderPath, finalSolutionName, finalExtensions, dryRun, ciMode, logLevel, profileName, cancellationToken);
 		}
 
 		private async Task<int> RunCore(
@@ -96,7 +92,7 @@ private async Task<int> RunCore(
 				return ValidationError("webresources", errors);
 
 			var serviceProvider = GetWebresourceSyncServices()
-				.AddXrmSyncConfiguration(new SharedOptions(profileName))
+				.AddXrmSyncConfiguration(new ExecutionContext(null, null, null, null, profileName))
 				.AddOptions(
 					options => options with
 					{
@@ -106,11 +102,6 @@ private async Task<int> RunCore(
 					}
 				)
 				.AddSingleton(MSOptions.Create(new WebresourceSyncCommandOptions(folderPath, solutionName, fileExtensionsList)))
-				.AddSingleton(sp =>
-				{
-					var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
-					return MSOptions.Create(new ExecutionModeOptions(config.DryRun));
-				})
 				.AddLogger()
 				.BuildServiceProvider();
 
diff --git a/XrmSync/Commands/XrmSyncCommandBase.cs b/XrmSync/Commands/XrmSyncCommandBase.cs
index 9c52205..8eda1be 100644
--- a/XrmSync/Commands/XrmSyncCommandBase.cs
+++ b/XrmSync/Commands/XrmSyncCommandBase.cs
@@ -1,7 +1,6 @@
 using System.CommandLine;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using XrmSync.Constants;
 using XrmSync.Dataverse.Interfaces;
 using XrmSync.Model;
 using XrmSync.Model.Exceptions;
@@ -18,90 +17,29 @@ internal abstract class XrmSyncCommandBase(string name, string description) : Co
 	protected const int E_OK = 0;
 	protected const int E_ERROR = 1;
 
-	// Shared options available to all commands
-	protected Option<string?> ProfileNameOption { get; private set; } = null!;
-
-	// Sync-specific shared options (populated by AddSyncOptions)
-	protected Option<string> SolutionName { get; private set; } = null!;
-	protected Option<bool?> DryRun { get; private set; } = null!;
-	protected Option<LogLevel?> LogLevel { get; private set; } = null!;
-	protected Option<bool?> CiMode { get; private set; } = null!;
-
 	public Command GetCommand() => this;
 
 	/// <summary>
 	/// Default implementation: this command does not handle profile sync items.
 	/// Override in sync sub-commands to handle a specific SyncItem subtype.
 	/// </summary>
-	public virtual Task<int?> ExecuteFromProfile(SyncItem syncItem, ProfileExecutionContext ctx, CancellationToken ct)
+	public virtual Task<int?> ExecuteFromProfile(SyncItem syncItem, ExecutionContext ctx, CancellationToken ct)
 		=> Task.FromResult<int?>(null);
 
 	/// <summary>
-	/// Adds the profile option to the command
+	/// Adds the --profile option to the command
 	/// </summary>
-	protected void AddSharedOptions()
-	{
-		ProfileNameOption = CliOptions.Config.Profile.CreateOption<string?>();
-		Add(ProfileNameOption);
-	}
+	protected void AddSharedOptions() => Add(CommandOptions.Profile);
 
 	/// <summary>
 	/// Adds sync-specific shared options: --solution, --dry-run, --log-level, --ci-mode
 	/// </summary>
 	protected void AddSyncOptions()
 	{
-		SolutionName = CliOptions.Solution.CreateOption<string>();
-		DryRun = CliOptions.Execution.DryRun.CreateOption<bool?>();
-		LogLevel = CliOptions.Logging.LogLevel.CreateOption<LogLevel?>();
-		CiMode = CliOptions.Logging.CiMode.CreateOption<bool?>();
-
-		Add(SolutionName);
-		Add(DryRun);
-		Add(LogLevel);
-		Add(CiMode);
-	}
-
-	/// <summary>
-	/// Gets the shared option values from a parse result
-	/// </summary>
-	protected SharedOptions GetSharedOptionValues(ParseResult parseResult)
-	{
-		var profileName = parseResult.GetValue(ProfileNameOption);
-		return new(profileName);
-	}
-
-	/// <summary>
-	/// Gets the sync-specific shared option values from a parse result
-	/// </summary>
-	protected (string? SolutionName, bool? DryRun, LogLevel? LogLevel, bool? CIMode) GetSyncSharedOptionValues(ParseResult parseResult)
-	{
-		var solutionName = parseResult.GetValue(SolutionName);
-		var dryRun = parseResult.GetValue(DryRun);
-		var logLevel = parseResult.GetValue(LogLevel);
-		var ciMode = parseResult.GetValue(CiMode);
-		return (solutionName, dryRun, logLevel, ciMode);
-	}
-
-	/// <summary>
-	/// Resolves the profile by name, throwing a consistent error if not found
-	/// </summary>
-	protected static ProfileConfiguration GetRequiredProfile(IServiceProvider sp, string? profileName, string optionsHint)
-	{
-		return sp.GetRequiredService<IConfigurationBuilder>().GetProfile(profileName)
-			?? throw new InvalidOperationException(
-				$"Profile '{profileName}' not found. " +
-				$"Either specify {optionsHint}, or use --profile with a valid profile name.");
-	}
-
-	/// <summary>
-	/// Loads configuration directly and resolves a profile.
-	/// Returns null when no profiles are configured.
-	/// Throws XrmSyncException when an explicitly requested profile is not found.
-	/// </summary>
-	protected static ProfileConfiguration? LoadProfile(string? profileName)
-	{
-		var configuration = new ConfigReader().GetConfiguration();
-		return new XrmSyncConfigurationBuilder(configuration).GetProfile(profileName);
+		Add(CommandOptions.Solution);
+		Add(CommandOptions.DryRun);
+		Add(CommandOptions.LogLevel);
+		Add(CommandOptions.CiMode);
 	}
 
 	/// <summary>
diff --git a/XrmSync/Commands/XrmSyncRootCommand.cs b/XrmSync/Commands/XrmSyncRootCommand.cs
index e2674a1..ec0b660 100644
--- a/XrmSync/Commands/XrmSyncRootCommand.cs
+++ b/XrmSync/Commands/XrmSyncRootCommand.cs
@@ -1,7 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using System.CommandLine;
-using XrmSync.Constants;
 using XrmSync.Extensions;
 using XrmSync.Model;
 using XrmSync.Options;
@@ -15,46 +14,23 @@ namespace XrmSync.Commands;
 internal class XrmSyncRootCommand : XrmSyncCommandBase
 {
 	private readonly List<IXrmSyncCommand> subCommands;
-	private readonly Option<bool?> dryRun;
-	private readonly Option<bool?> ciMode;
-	private readonly Option<LogLevel?> logLevel;
-	private readonly Option<string?> assembly;
-	private readonly Option<string?> solution;
-	private readonly Option<string?> folder;
-	private readonly Option<string[]?> fileExtensions;
-	private readonly Option<string?> prefix;
-	private readonly Option<IdentityOperation?> operation;
-	private readonly Option<string?> clientId;
-	private readonly Option<string?> tenantId;
 
 	public XrmSyncRootCommand(List<IXrmSyncCommand> subCommands)
 		: base("xrmsync", "XrmSync - Synchronize your Dataverse plugins and webresources")
 	{
 		this.subCommands = subCommands;
 
-		dryRun = CliOptions.Execution.DryRun.CreateOption<bool?>();
-		ciMode = CliOptions.Logging.CiMode.CreateOption<bool?>();
-		logLevel = CliOptions.Logging.LogLevel.CreateOption<LogLevel?>();
-		assembly = CliOptions.Assembly.CreateOption<string?>();
-		solution = CliOptions.Solution.CreateOption<string?>();
-		folder = CliOptions.Webresource.CreateOption<string?>();
-		fileExtensions = CliOptions.FileExtensions.CreateOption<string[]?>();
-		prefix = CliOptions.Analysis.Prefix.CreateOption<string?>();
-		operation = CliOptions.ManagedIdentity.Operation.CreateOption<IdentityOperation?>();
-		clientId = CliOptions.ManagedIdentity.ClientId.CreateOption<string?>();
-		tenantId = CliOptions.ManagedIdentity.TenantId.CreateOption<string?>();
-
-		Add(dryRun);
-		Add(ciMode);
-		Add(logLevel);
-		Add(assembly);
-		Add(solution);
-		Add(folder);
-		Add(fileExtensions);
-		Add(prefix);
-		Add(operation);
-		Add(clientId);
-		Add(tenantId);
+		Add(CommandOptions.DryRun);
+		Add(CommandOptions.CiMode);
+		Add(CommandOptions.LogLevel);
+		Add(CommandOptions.Assembly);
+		Add(CommandOptions.Solution);
+		Add(CommandOptions.Folder);
+		Add(CommandOptions.FileExtensions);
+		Add(CommandOptions.Prefix);
+		Add(CommandOptions.Operation);
+		Add(CommandOptions.ClientId);
+		Add(CommandOptions.TenantId);
 
 		AddSharedOptions();
 		SetAction(ExecuteAsync);
@@ -62,25 +38,24 @@ public XrmSyncRootCommand(List<IXrmSyncCommand> subCommands)
 
 	private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken cancellationToken)
 	{
-		var sharedOptions = GetSharedOptionValues(parseResult);
-
-		var dryRunOverride = parseResult.GetValue(dryRun);
-		var ciModeOverride = parseResult.GetValue(ciMode);
-		var logLevelOverride = parseResult.GetValue(logLevel);
-		var assemblyOverride = parseResult.GetValue(assembly);
-		var solutionOverride = parseResult.GetValue(solution);
-		var folderOverride = parseResult.GetValue(folder);
-		var fileExtensionsOverride = parseResult.GetValue(fileExtensions);
-		var prefixOverride = parseResult.GetValue(prefix);
-		var operationOverride = parseResult.GetValue(operation);
-		var clientIdOverride = parseResult.GetValue(clientId);
-		var tenantIdOverride = parseResult.GetValue(tenantId);
+		var profileName = parseResult.GetValue(CommandOptions.Profile);
+		var dryRunOverride = parseResult.GetValue(CommandOptions.DryRun);
+		var ciModeOverride = parseResult.GetValue(CommandOptions.CiMode);
+		var logLevelOverride = parseResult.GetValue(CommandOptions.LogLevel);
+		var assemblyOverride = parseResult.GetValue(CommandOptions.Assembly);
+		var solutionOverride = parseResult.GetValue(CommandOptions.Solution);
+		var folderOverride = parseResult.GetValue(CommandOptions.Folder);
+		var fileExtensionsOverride = parseResult.GetValue(CommandOptions.FileExtensions);
+		var prefixOverride = parseResult.GetValue(CommandOptions.Prefix);
+		var operationOverride = parseResult.GetValue(CommandOptions.Operation);
+		var clientIdOverride = parseResult.GetValue(CommandOptions.ClientId);
+		var tenantIdOverride = parseResult.GetValue(CommandOptions.TenantId);
 
 		ProfileConfiguration? rawProfile;
 		XrmSyncConfiguration rawConfig;
 		try
 		{
-			(rawProfile, rawConfig) = LoadProfileAndConfig(sharedOptions.ProfileName);
+			(rawProfile, rawConfig) = LoadProfileAndConfig(profileName);
 		}
 		catch (Model.Exceptions.XrmSyncException ex)
 		{
@@ -136,7 +111,7 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 
 		var serviceProvider = new ServiceCollection()
 			.AddSingleton(MSOptions.Create(mergedConfig))
-			.AddSingleton(MSOptions.Create(sharedOptions))
+			.AddSingleton(MSOptions.Create(new ExecutionContext(null, mergedConfig.DryRun, mergedConfig.CiMode, mergedConfig.LogLevel, profileName)))
 			.AddSingleton<IConfigurationValidator, XrmSyncConfigurationValidator>()
 			.AddLogger()
 			.BuildServiceProvider();
@@ -168,12 +143,12 @@ private async Task<int> ExecuteAsync(ParseResult parseResult, CancellationToken
 			return E_ERROR;
 		}
 
-		var ctx = new ProfileExecutionContext(
+		var ctx = new ExecutionContext(
 			SolutionName: mergedProfile.SolutionName,
 			DryRun: mergedConfig.DryRun,
 			CiMode: mergedConfig.CiMode,
 			LogLevel: mergedConfig.LogLevel,
-			ProfileName: sharedOptions.ProfileName);
+			ProfileName: profileName);
 
 		var success = true;
 
diff --git a/XrmSync/Extensions/ServiceCollectionExtensions.cs b/XrmSync/Extensions/ServiceCollectionExtensions.cs
index 65aea1a..7198c5e 100644
--- a/XrmSync/Extensions/ServiceCollectionExtensions.cs
+++ b/XrmSync/Extensions/ServiceCollectionExtensions.cs
@@ -11,12 +11,21 @@ namespace XrmSync.Extensions;
 
 internal static class ServiceCollectionExtensions
 {
-	public static IServiceCollection AddXrmSyncConfiguration(this IServiceCollection services, SharedOptions sharedOptions)
+	public static IServiceCollection AddXrmSyncConfiguration(this IServiceCollection services, ExecutionContext executionContext)
 	{
 		services
 			.AddSingleton<IConfigReader, ConfigReader>()
 			.AddSingleton<IConfigurationValidator, XrmSyncConfigurationValidator>()
-			.AddSingleton(MSOptions.Create(sharedOptions))
+			.AddSingleton(sp =>
+			{
+				var config = sp.GetRequiredService<IOptions<XrmSyncConfiguration>>().Value;
+				return MSOptions.Create(executionContext with
+				{
+					DryRun = config.DryRun,
+					CiMode = config.CiMode,
+					LogLevel = config.LogLevel,
+				});
+			})
 			.AddSingleton(sp => sp.GetRequiredService<IConfigReader>().GetConfiguration())
 			.AddSingleton<IConfigurationBuilder, XrmSyncConfigurationBuilder>();
 
diff --git a/XrmSync/GlobalUsings.cs b/XrmSync/GlobalUsings.cs
new file mode 100644
index 0000000..23e2014
--- /dev/null
+++ b/XrmSync/GlobalUsings.cs
@@ -0,0 +1 @@
+global using ExecutionContext = XrmSync.Model.ExecutionContext;
diff --git a/XrmSync/Options/ConfigValidationOutput.cs b/XrmSync/Options/ConfigValidationOutput.cs
index f5c9ceb..a264572 100644
--- a/XrmSync/Options/ConfigValidationOutput.cs
+++ b/XrmSync/Options/ConfigValidationOutput.cs
@@ -8,7 +8,7 @@ namespace XrmSync.Options;
 internal class ConfigValidationOutput(
 	IConfiguration configuration,
 	IOptions<XrmSyncConfiguration>? configOptions = null,
-	IOptions<SharedOptions>? sharedOptions = null) : IConfigValidationOutput
+	IOptions<ExecutionContext>? sharedOptions = null) : IConfigValidationOutput
 {
 	public Task OutputValidationResult(CancellationToken cancellationToken = default)
 	{
diff --git a/XrmSync/Options/XrmSyncConfigurationValidator.cs b/XrmSync/Options/XrmSyncConfigurationValidator.cs
index 5d06305..176491f 100644
--- a/XrmSync/Options/XrmSyncConfigurationValidator.cs
+++ b/XrmSync/Options/XrmSyncConfigurationValidator.cs
@@ -4,7 +4,7 @@
 
 namespace XrmSync.Options;
 
-internal partial class XrmSyncConfigurationValidator(IOptions<XrmSyncConfiguration> configuration, IOptions<SharedOptions> sharedOptions) : IConfigurationValidator
+internal partial class XrmSyncConfigurationValidator(IOptions<XrmSyncConfiguration> configuration, IOptions<ExecutionContext> sharedOptions) : IConfigurationValidator
 {
 	public void Validate(ConfigurationScope scope)
 	{

From 9a76833f75608021bf8758c0c3c1ba11ad24385b Mon Sep 17 00:00:00 2001
From: Morten Holt <mkh@contextand.com>
Date: Thu, 23 Apr 2026 17:43:52 +0200
Subject: [PATCH 5/6] Fix: Wrong error message

---
 XrmSync/Options/ConfigValidationOutput.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/XrmSync/Options/ConfigValidationOutput.cs b/XrmSync/Options/ConfigValidationOutput.cs
index a264572..6382e42 100644
--- a/XrmSync/Options/ConfigValidationOutput.cs
+++ b/XrmSync/Options/ConfigValidationOutput.cs
@@ -14,7 +14,7 @@ public Task OutputValidationResult(CancellationToken cancellationToken = default
 	{
 		if (configOptions == null || sharedOptions == null)
 		{
-			throw new InvalidOperationException("ConfigValidationOutput requires XrmSyncConfiguration and SharedOptions to validate configuration. Use OutputConfigList for listing profiles.");
+			throw new InvalidOperationException("ConfigValidationOutput requires XrmSyncConfiguration and ExecutionContext to validate configuration. Use OutputConfigList for listing profiles.");
 		}
 
 		var profileName = sharedOptions.Value.ProfileName;

From 4b7aca1abce8797557bdbad9798edc26af3a0ec9 Mon Sep 17 00:00:00 2001
From: Morten Holt <mkh@contextand.com>
Date: Fri, 24 Apr 2026 07:47:06 +0200
Subject: [PATCH 6/6] CHORE: Update Changelog to prep release

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f241561..33fe0b0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+### v1.0.0-preview.19 - 24 April 2026
+* Refactor / Fix: Complete rewrite of the option passing logic
+
 ### v1.0.0-preview.18 - 22 April 2026
 * Fix: Handling of passing boolean arguments through from CLI to final command
 * Refactor: Only print the header and Dataverse connection once during execution