Program.cs

using CobolToQuarkusMigration.Helpers;
using CobolToQuarkusMigration.Models;
using CobolToQuarkusMigration.Persistence;
using CobolToQuarkusMigration.Processes;
using CobolToQuarkusMigration.Agents;
using CobolToQuarkusMigration.Agents.Infrastructure;
using CobolToQuarkusMigration.Mcp;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Logging;
using System.CommandLine;
using System.Globalization;
using Microsoft.Extensions.Logging.Console;
using GitHub.Copilot;

namespace CobolToQuarkusMigration;

/// <summary>
/// Main entry point for the COBOL to Java/C# migration tool.
/// Supports multiple AI providers:
/// - AzureOpenAI (ResponsesApiClient for Codex + IChatClient for chat)
/// - GitHubCopilot (IChatClient for all models: Claude, Codex, GPT, Grok, etc.)
/// - OpenAI (IChatClient for GPT models)
/// </summary>
internal static class Program
{
    public static async Task<int> Main(string[] args)
    {
        // Start live log capture for portal's Live Run Log panel
        var logsDirectory = Path.Combine(Directory.GetCurrentDirectory(), "Logs");
        Directory.CreateDirectory(logsDirectory);

        // Only enable live logging for migration runs (not MCP server or conversation modes)
        var isMigrationRun = !args.Contains("mcp") && !args.Contains("conversation") && !args.Contains("estate-graph");
        LiveLogWriter? liveLogWriter = null;

        if (isMigrationRun)
        {
            liveLogWriter = LiveLogWriter.Start(logsDirectory);
        }

        try
        {
            // Configure logger to write to Stderr to avoid breaking MCP JSON-RPC on Stdout
            using var loggerFactory = LoggerFactory.Create(builder =>
            {
                builder.AddConsole(options =>
                {
                    options.LogToStandardErrorThreshold = LogLevel.Trace;
                });
                // Suppress verbose JSON-RPC logging from GitHub Copilot SDK
                builder.AddFilter("GitHub.Copilot.SDK", LogLevel.Warning);
            });
            var logger = loggerFactory.CreateLogger(nameof(Program));
            var fileHelper = new FileHelper(loggerFactory.CreateLogger<FileHelper>());
            var settingsHelper = new SettingsHelper(loggerFactory.CreateLogger<SettingsHelper>());

            if (!ValidateAndLoadConfiguration(RequiresAiSettings(args)))
            {
                return 1;
            }

            var rootCommand = BuildRootCommand(loggerFactory, logger, fileHelper, settingsHelper);
            var exitCode = await rootCommand.InvokeAsync(args);

            // Main returning int overrides Environment.ExitCode entirely, so a quality gate that
            // only sets the latter would never fail a build. Handler failures still win.
            return exitCode != 0 ? exitCode : Environment.ExitCode;
        }
        finally
        {
            // Stop live logging and restore console
            if (liveLogWriter != null)
            {
                LiveLogWriter.Stop();
            }
        }
    }

    private static RootCommand BuildRootCommand(ILoggerFactory loggerFactory, ILogger logger, FileHelper fileHelper, SettingsHelper settingsHelper)
    {
        var rootCommand = new RootCommand("COBOL to Java Quarkus Migration Tool (Agent Framework)");

        var cobolSourceOption = new Option<string>("--source", "Path to the folder containing COBOL source files and copybooks")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        cobolSourceOption.AddAlias("-s");
        rootCommand.AddOption(cobolSourceOption);

        var javaOutputOption = new Option<string>("--java-output", () => "output", "Path to the folder for Java output files")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        javaOutputOption.AddAlias("-j");
        rootCommand.AddOption(javaOutputOption);

        var reverseEngineerOutputOption = new Option<string>("--reverse-engineer-output", () => "output", "Path to the folder for reverse engineering output")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        reverseEngineerOutputOption.AddAlias("-reo");
        rootCommand.AddOption(reverseEngineerOutputOption);

        var reverseEngineerOnlyOption = new Option<bool>("--reverse-engineer-only", () => false, "Run only reverse engineering (skip Java conversion)")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        reverseEngineerOnlyOption.AddAlias("-reo-only");
        rootCommand.AddOption(reverseEngineerOnlyOption);

        var skipReverseEngineeringOption = new Option<bool>("--skip-reverse-engineering", () => false, "Skip reverse engineering and run only Java conversion")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        skipReverseEngineeringOption.AddAlias("-skip-re");
        rootCommand.AddOption(skipReverseEngineeringOption);

        var reuseReOption = new Option<bool>("--reuse-re", () => false, "Inject reverse-engineered business logic into the conversion prompts (off by default). In a full run this uses the run's own reverse engineering; with --skip-reverse-engineering it loads the latest persisted run over the same source folder")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        reuseReOption.AddAlias("-reuse-re");
        reuseReOption.AddAlias("--use-re-context");
        rootCommand.AddOption(reuseReOption);

        var programsOption = new Option<string>(
            "--programs",
            () => "",
            "Comma-separated programs to convert, by name or source-relative path. "
            + "Empty converts the whole estate. Copybooks always travel with the selection.");
        programsOption.AddAlias("-programs");
        rootCommand.AddOption(programsOption);

        var configOption = new Option<string>("--config", () => "Config/appsettings.json", "Path to the configuration file")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        configOption.AddAlias("-c");
        rootCommand.AddOption(configOption);

        var resumeOption = new Option<bool>("--resume", () => false, "Resume from the last migration run if possible")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        resumeOption.AddAlias("-r");
        rootCommand.AddOption(resumeOption);

        var conversationCommand = BuildConversationCommand(loggerFactory);
        rootCommand.AddCommand(conversationCommand);

        var mcpCommand = BuildMcpCommand(loggerFactory, settingsHelper);
        rootCommand.AddCommand(mcpCommand);

        var reverseEngineerCommand = BuildReverseEngineerCommand(loggerFactory, fileHelper, settingsHelper);
        rootCommand.AddCommand(reverseEngineerCommand);

        var listModelsCommand = BuildListModelsCommand(loggerFactory);
        rootCommand.AddCommand(listModelsCommand);

        // Incremental / targeted REKT scan planning and recording.
        rootCommand.AddCommand(CobolToQuarkusMigration.Cli.RektScanCacheCommand.Build(loggerFactory));

        // Curated program-facts.json extraction from REKT artifacts.
        rootCommand.AddCommand(CobolToQuarkusMigration.Cli.ProgramFactsCommand.Build(loggerFactory));

        // Deterministic JCL job facts and dataset lineage.
        rootCommand.AddCommand(CobolToQuarkusMigration.Cli.JclFactsCommand.Build());
        rootCommand.AddCommand(CobolToQuarkusMigration.Cli.JclJobsCommand.Build());
        rootCommand.AddCommand(CobolToQuarkusMigration.Cli.JclProgramsCommand.Build());

        // Deterministic estate graph: clusters, carve scores and migration waves.
        rootCommand.AddCommand(CobolToQuarkusMigration.Cli.EstateGraphCommand.Build());

        rootCommand.SetHandler(async (context) =>
        {
            var cobolSource = context.ParseResult.GetValueForOption(cobolSourceOption)!;
            var javaOutput = context.ParseResult.GetValueForOption(javaOutputOption)!;
            var reverseEngineerOutput = context.ParseResult.GetValueForOption(reverseEngineerOutputOption)!;
            var reverseEngineerOnly = context.ParseResult.GetValueForOption(reverseEngineerOnlyOption);
            var skipReverseEngineering = context.ParseResult.GetValueForOption(skipReverseEngineeringOption);
            var reuseRe = context.ParseResult.GetValueForOption(reuseReOption);
            var configPath = context.ParseResult.GetValueForOption(configOption)!;
            var resume = context.ParseResult.GetValueForOption(resumeOption);
            var programs = context.ParseResult.GetValueForOption(programsOption) ?? "";

            await RunMigrationAsync(loggerFactory, logger, fileHelper, settingsHelper, cobolSource,
                javaOutput, reverseEngineerOutput, reverseEngineerOnly, skipReverseEngineering,
                reuseRe, configPath, resume, SplitPrograms(programs));
        });

        return rootCommand;
    }

    private static Command BuildConversationCommand(ILoggerFactory loggerFactory)
    {
        var conversationCommand = new Command("conversation", "Generate a readable conversation log from migration logs");

        var sessionIdOption = new Option<string>("--session-id", "Specific session ID to generate conversation for (optional)")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        sessionIdOption.AddAlias("-sid");
        conversationCommand.AddOption(sessionIdOption);

        var logDirOption = new Option<string>("--log-dir", () => "Logs", "Path to the logs directory")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        logDirOption.AddAlias("-ld");
        conversationCommand.AddOption(logDirOption);

        var liveOption = new Option<bool>("--live", () => false, "Enable live conversation feed that updates in real-time");
        liveOption.AddAlias("-l");
        conversationCommand.AddOption(liveOption);

        conversationCommand.SetHandler(async (string sessionId, string logDir, bool live) =>
        {
            await GenerateConversationAsync(loggerFactory, sessionId, logDir, live);
        }, sessionIdOption, logDirOption, liveOption);

        return conversationCommand;
    }

    private static Command BuildMcpCommand(ILoggerFactory loggerFactory, SettingsHelper settingsHelper)
    {
        var mcpCommand = new Command("mcp", "Expose migration insights over the Model Context Protocol");

        var runIdOption = new Option<int?>("--run-id", () => null, "Specific run ID to expose via MCP (defaults to latest)")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        runIdOption.AddAlias("-r");
        mcpCommand.AddOption(runIdOption);

        var configOption = new Option<string>("--config", () => "Config/appsettings.json", "Path to the configuration file")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        configOption.AddAlias("-c");
        mcpCommand.AddOption(configOption);

        mcpCommand.SetHandler(async (int? runId, string configPath) =>
        {
            await RunMcpServerAsync(loggerFactory, settingsHelper, runId, configPath);
        }, runIdOption, configOption);

        return mcpCommand;
    }

    private static Command BuildReverseEngineerCommand(ILoggerFactory loggerFactory, FileHelper fileHelper, SettingsHelper settingsHelper)
    {
        var reverseEngineerCommand = new Command("reverse-engineer", "Extract business logic from COBOL applications");

        var cobolSourceOption = new Option<string>("--source", "Path to the folder containing COBOL source files")
        {
            Arity = ArgumentArity.ExactlyOne
        };
        cobolSourceOption.AddAlias("-s");
        reverseEngineerCommand.AddOption(cobolSourceOption);

        var outputOption = new Option<string>("--output", () => "output", "Path to the output folder")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        outputOption.AddAlias("-o");
        reverseEngineerCommand.AddOption(outputOption);

        var configOption = new Option<string>("--config", () => "Config/appsettings.json", "Path to the configuration file")
        {
            Arity = ArgumentArity.ZeroOrOne
        };
        configOption.AddAlias("-c");
        reverseEngineerCommand.AddOption(configOption);

        // doctor.sh has always passed --programs to this command, and this command has never
        // accepted it, so "reverse-eng --program X" failed outright instead of analysing X.
        // Reverse engineering is subject to the same reason conversion is: a full estate run
        // costs hours, and a change is judged on one program long before it is trusted on sixty.
        var programsOption = new Option<string>(
            "--programs",
            () => "",
            "Comma-separated programs to analyse, by name or source-relative path. "
            + "Empty analyses the whole estate. Copybooks the selection reaches travel with it.");
        programsOption.AddAlias("-programs");
        reverseEngineerCommand.AddOption(programsOption);

        reverseEngineerCommand.SetHandler(async (string cobolSource, string output, string configPath, string programs) =>
        {
            var selection = SplitPrograms(programs);
            if (selection.Count > 0)
            {
                fileHelper.ProgramSelection = selection;
                Console.WriteLine(
                    $"🎯 Analysing {selection.Count} selected program(s): {string.Join(", ", selection)}");
            }

            await RunReverseEngineeringAsync(loggerFactory, fileHelper, settingsHelper, cobolSource, output, configPath);
        }, cobolSourceOption, outputOption, configOption, programsOption);

        return reverseEngineerCommand;
    }

    private static Command BuildListModelsCommand(ILoggerFactory loggerFactory)
    {
        var listModelsCommand = new Command("list-models", "List available models from the configured AI provider");

        listModelsCommand.SetHandler(async () =>
        {
            var logger = loggerFactory.CreateLogger("ListModels");

            // list-models always uses Copilot SDK — it's only called during
            // './doctor.sh setup' before config is written, so don't check
            // AZURE_OPENAI_SERVICE_TYPE (it will be AzureOpenAI at this point).
            try
            {
                var auth = CobolToQuarkusMigration.Agents.Infrastructure.CopilotAuth.Resolve();
                Console.WriteLine($"Querying models via GitHub Copilot SDK (auth: {auth.Description})...");
                using var client = new CopilotClient(CobolToQuarkusMigration.Agents.Infrastructure.CopilotAuth.Apply(
                    new CopilotClientOptions { Mode = CopilotClientMode.CopilotCli }, auth));
                var models = await client.ListModelsAsync();
                Console.WriteLine($"Available models ({models.Count}):");
                foreach (var model in models.OrderBy(m => m.Name))
                {
                    var id = model.Id ?? model.Name;
                    Console.WriteLine($"  • {id}");
                }
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Failed to list models via Copilot SDK");
                Console.WriteLine($"Error: {ex.Message}");
                Console.WriteLine("Sign in with 'copilot login', or set COPILOT_GITHUB_TOKEN to a fine-grained token with the 'Copilot Requests' permission.");
            }
        });

        return listModelsCommand;
    }

    private static async Task GenerateConversationAsync(ILoggerFactory loggerFactory, string sessionId, string logDir, bool live)
    {
        try
        {
            var enhancedLogger = new EnhancedLogger(loggerFactory.CreateLogger<EnhancedLogger>());
            var logCombiner = new LogCombiner(logDir, enhancedLogger);

            Console.WriteLine("🤖 Generating conversation log from migration data...");

            string outputPath;
            if (live)
            {
                Console.WriteLine("📡 Starting live conversation feed...");
                outputPath = await logCombiner.CreateLiveConversationFeedAsync();
                Console.WriteLine($"✅ Live conversation feed created: {outputPath}");
                Console.WriteLine("📝 The conversation will update automatically as new logs are generated.");
                Console.WriteLine("Press Ctrl+C to stop monitoring.");

                await Task.Delay(-1);
            }
            else
            {
                outputPath = await logCombiner.CreateConversationNarrativeAsync(sessionId);
                Console.WriteLine($"✅ Conversation narrative created: {outputPath}");

                if (File.Exists(outputPath))
                {
                    var preview = await File.ReadAllTextAsync(outputPath);
                    var lines = preview.Split('\n').Take(20).ToArray();

                    Console.WriteLine("\n📖 Preview of conversation:");
                    Console.WriteLine("═══════════════════════════════════════");
                    foreach (var line in lines)
                    {
                        Console.WriteLine(line);
                    }

                    if (preview.Split('\n').Length > 20)
                    {
                        Console.WriteLine("... (and more)");
                    }

                    Console.WriteLine("═══════════════════════════════════════");
                }
            }
        }
        catch (Exception ex)
        {
            loggerFactory.CreateLogger(nameof(Program)).LogError(ex, "Error generating conversation log");
            Environment.Exit(1);
        }
    }

    private static async Task RunMcpServerAsync(ILoggerFactory loggerFactory, SettingsHelper settingsHelper, int? runId, string configPath)
    {
        try
        {
            AppSettings? loadedSettings = await settingsHelper.LoadSettingsAsync<AppSettings>(configPath);
            var settings = loadedSettings ?? new AppSettings();
            LoadEnvironmentVariables();
            OverrideSettingsFromEnvironment(settings);

            var databasePath = settings.ApplicationSettings.MigrationDatabasePath;
            if (!Path.IsPathRooted(databasePath))
            {
                databasePath = Path.GetFullPath(databasePath);
            }

            var repositoryLogger = loggerFactory.CreateLogger<SqliteMigrationRepository>();
            var sqliteRepository = new SqliteMigrationRepository(databasePath, repositoryLogger);
            await sqliteRepository.InitializeAsync();

            var mcpLogger = loggerFactory.CreateLogger(nameof(Program));
            var neo4jRepository = await Neo4jConnection.TryOpenAsync(settings.ApplicationSettings.Neo4j, loggerFactory, mcpLogger);

            var hybridLogger = loggerFactory.CreateLogger<HybridMigrationRepository>();
            var repository = new HybridMigrationRepository(sqliteRepository, neo4jRepository, hybridLogger);
            await repository.InitializeAsync();

            var targetRunId = runId;
            if (!targetRunId.HasValue)
            {
                var latest = await repository.GetLatestRunAsync();
                if (latest is null)
                {
                    Console.Error.WriteLine("No migration runs available in the database. Run the migration process first: ./doctor.sh reverse-eng or ./doctor.sh run (rekt-full fills the REKT graph only).");
                    return;
                }

                targetRunId = latest.RunId;
            }

            // Create EnhancedLogger early so it can track ALL API calls
            var enhancedLogger = new EnhancedLogger(loggerFactory.CreateLogger<EnhancedLogger>());
            // Get API version from environment or default
            var apiVersion = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_VERSION") ?? "2025-04-01-preview";

            // Create ResponsesApiClient for code agents (only for AzureOpenAI with Codex models)
            ResponsesApiClient? responsesApiClient = null;
            var serviceType = settings.AISettings.ServiceType ?? "AzureOpenAI";
            var codeModelCaps = CobolToQuarkusMigration.Models.ModelCapabilities.Detect(settings.AISettings.ModelId);

            if (serviceType.Equals("AzureOpenAI", StringComparison.OrdinalIgnoreCase) &&
                codeModelCaps.SupportsResponsesApi &&
                !string.IsNullOrEmpty(settings.AISettings.Endpoint) &&
                !string.IsNullOrEmpty(settings.AISettings.DeploymentName))
            {
                responsesApiClient = new ResponsesApiClient(
                    settings.AISettings.Endpoint,
                    string.Empty,
                    settings.AISettings.DeploymentName,
                    loggerFactory.CreateLogger<ResponsesApiClient>(),
                    enhancedLogger,
                    profile: settings.ModelProfile,
                    apiVersion: apiVersion,
                    rateLimitSafetyFactor: settings.ChunkingSettings.RateLimitSafetyFactor);
                mcpLogger.LogInformation("ResponsesApiClient initialized for {Model} (Entra ID)", settings.AISettings.DeploymentName);
            }

            // Create IChatClient for MCP server — works with all providers
            IChatClient? chatClient = null;
            try
            {
                chatClient = ChatClientFactory.CreateChatClientFromSettings(settings.AISettings, mcpLogger);
                mcpLogger.LogInformation("IChatClient initialized for MCP server via {Provider}", serviceType);
            }
            catch (Exception chatEx)
            {
                mcpLogger.LogWarning(chatEx, "Could not create chat client for MCP server");
            }

            var serverLogger = loggerFactory.CreateLogger<McpServer>();
            var server = new McpServer(repository, targetRunId.Value, serverLogger, settings.AISettings, chatClient, responsesApiClient);
            var cts = new CancellationTokenSource();

            Console.CancelKeyPress += (sender, args) =>
            {
                args.Cancel = true;
                cts.Cancel();
            };

            await server.RunAsync(cts.Token);
        }
        catch (Exception ex)
        {
            loggerFactory.CreateLogger(nameof(Program)).LogError(ex, "Error running MCP server");
            Environment.Exit(1);
        }
    }

    private static void ConfigureSmartChunking(AppSettings settings, string chatDeployment, ILogger logger)
    {
        // 1. TRUST THE CONFIGURATION FIRST:
        if (settings.AISettings.ContextWindowSize.HasValue)
        {
            var size = settings.AISettings.ContextWindowSize.Value;
            if (size >= 100_000)
            {
                settings.ChunkingSettings.AutoChunkLineThreshold = 25_000;
                settings.ChunkingSettings.AutoChunkCharThreshold = 400_000;
                settings.ChunkingSettings.MaxTokensPerChunk = 90_000;

                logger.LogInformation("🚀 Optimized Strategy: 'Whole-Program Analysis' enabled based on configured ContextWindowSize ({Size} tokens).", size);
                return;
            }
        }

        // 2. USE MODEL CAPABILITIES DETECTION (replaces magic string matching):
        // Same precedence as before, but whitespace-aware: these settings bind to an empty
        // string when absent, so `??` would hand an empty model name to Detect().
        var targetModel = new[] { settings.AISettings.ModelId, chatDeployment, settings.AISettings.ChatModelId }
            .FirstOrDefault(m => !string.IsNullOrWhiteSpace(m)) ?? string.Empty;

        if (!string.IsNullOrEmpty(targetModel))
        {
            var caps = CobolToQuarkusMigration.Models.ModelCapabilities.Detect(targetModel);
            if (caps.ContextWindowSize >= 100_000)
            {
                settings.ChunkingSettings.AutoChunkLineThreshold = 25_000;
                settings.ChunkingSettings.AutoChunkCharThreshold = 400_000;
                settings.ChunkingSettings.MaxTokensPerChunk = 90_000;

                logger.LogInformation("🚀 High-context model detected ({Model}, family={Family}, context={Context}). " +
                    "'Whole-Program Analysis' enabled for files up to {NewLines} lines.",
                    targetModel, caps.Family, caps.ContextWindowSize, settings.ChunkingSettings.AutoChunkLineThreshold);
            }
        }
    }

    /// <summary>
    /// Stops a run whose configured models the provider does not offer, before any COBOL is read.
    /// Returns false when the caller should abort.
    /// </summary>
    private static async Task<bool> PreflightModelsAsync(AppSettings settings, string serviceType, ILogger logger)
    {
        var isCopilot = serviceType.Equals("GitHubCopilot", StringComparison.OrdinalIgnoreCase) ||
                        serviceType.Equals("GitHubCopilotSDK", StringComparison.OrdinalIgnoreCase);
        if (!isCopilot)
        {
            // Azure deployments cannot be enumerated with the credentials we hold here, so the
            // provider's own error remains the source of truth for that path.
            return true;
        }

        var error = await Helpers.ModelPreflight.ValidateCopilotModelsAsync(
            new[]
            {
                settings.AISettings.ResolveCobolAnalyzerModelId(),
                settings.AISettings.ResolveJavaConverterModelId(),
                settings.AISettings.ResolveDependencyMapperModelId(),
                settings.AISettings.ResolveChatModelId(),
            },
            logger);

        if (error is null)
        {
            return true;
        }

        Console.WriteLine();
        Console.WriteLine("❌ Model Validation Failed");
        Console.WriteLine("=====================================");
        Console.WriteLine(error);
        Console.WriteLine();
        return false;
    }

    private static async Task RunMigrationAsync(ILoggerFactory loggerFactory, ILogger logger, FileHelper fileHelper, SettingsHelper settingsHelper, string cobolSource, string javaOutput, string reverseEngineerOutput, bool reverseEngineerOnly, bool skipReverseEngineering, bool reuseRe, string configPath, bool resume, IReadOnlyList<string>? programSelection = null)
    {
        try
        {
            logger.LogInformation("Loading settings from {ConfigPath}", configPath);
            AppSettings? loadedSettings = await settingsHelper.LoadSettingsAsync<AppSettings>(configPath);
            var settings = loadedSettings ?? new AppSettings();

            LoadEnvironmentVariables();
            OverrideSettingsFromEnvironment(settings);

            if (programSelection is { Count: > 0 })
            {
                settings.ApplicationSettings.ProgramSelection = programSelection.ToList();
                fileHelper.ProgramSelection = settings.ApplicationSettings.ProgramSelection;
                Console.WriteLine(
                    $"🎯 Converting {programSelection.Count} selected program(s): {string.Join(", ", programSelection)}");
            }
            else if (settings.ApplicationSettings.ProgramSelection.Count > 0)
            {
                fileHelper.ProgramSelection = settings.ApplicationSettings.ProgramSelection;
            }

            if (string.IsNullOrEmpty(settings.ApplicationSettings.CobolSourceFolder))
            {
                logger.LogError("COBOL source folder not specified. Use --source option or set in config file.");
                Environment.Exit(1);
            }

            // Output folder validation - check both Java and C# based on target
            var targetLanguage = settings.ApplicationSettings.TargetLanguage;
            if (targetLanguage == TargetLanguage.CSharp)
            {
                // For C#, use CSharpOutputFolder if set, otherwise fall back to JavaOutputFolder or default
                if (string.IsNullOrEmpty(settings.ApplicationSettings.CSharpOutputFolder) &&
                    string.IsNullOrEmpty(settings.ApplicationSettings.JavaOutputFolder))
                {
                    settings.ApplicationSettings.CSharpOutputFolder = "output/csharp";
                    logger.LogInformation("Using default C# output folder: output/csharp");
                }
            }
            else
            {
                // For Java, require JavaOutputFolder
                if (string.IsNullOrEmpty(settings.ApplicationSettings.JavaOutputFolder))
                {
                    logger.LogError("Java output folder not specified. Use --java-output option or set in config file.");
                    Environment.Exit(1);
                }
            }

            if (string.IsNullOrEmpty(settings.AISettings.Endpoint) &&
                !settings.AISettings.ServiceType.Equals("GitHubCopilot", StringComparison.OrdinalIgnoreCase) &&
                !settings.AISettings.ServiceType.Equals("GitHubCopilotSDK", StringComparison.OrdinalIgnoreCase) &&
                !settings.AISettings.ServiceType.Equals("OpenAI", StringComparison.OrdinalIgnoreCase))
            {
                logger.LogError("AI configuration incomplete. Set endpoint for AzureOpenAI, or change ServiceType to GitHubCopilot/GitHubCopilotSDK/OpenAI.");
                logger.LogError("You can set them in Config/ai-config.local.env or as environment variables.");
                Environment.Exit(1);
            }

            if (string.IsNullOrEmpty(settings.AISettings.ModelId))
            {
                logger.LogError("ModelId is not configured. Set AISettings:ModelId in appsettings.json or AZURE_OPENAI_MODEL_ID environment variable.");
                Environment.Exit(1);
            }

            // Create EnhancedLogger early so it can track ALL API calls
            var enhancedLogger = new EnhancedLogger(loggerFactory.CreateLogger<EnhancedLogger>());

            // Get API version from environment or default
            var apiVersion = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_VERSION") ?? "2025-04-01-preview";

            // Create AI clients based on provider
            var serviceType = settings.AISettings.ServiceType ?? "AzureOpenAI";
            var codeModelCaps = CobolToQuarkusMigration.Models.ModelCapabilities.Detect(settings.AISettings.ModelId);

            // ResponsesApiClient only for Azure OpenAI Codex models (not for GitHub Copilot SDK)
            ResponsesApiClient? responsesApiClient = null;
            if (!IsGitHubCopilotSdkMode() &&
                serviceType.Equals("AzureOpenAI", StringComparison.OrdinalIgnoreCase) &&
                codeModelCaps.SupportsResponsesApi)
            {
                responsesApiClient = new ResponsesApiClient(
                    settings.AISettings.Endpoint,
                    string.Empty,
                    settings.AISettings.DeploymentName,
                    loggerFactory.CreateLogger<ResponsesApiClient>(),
                    enhancedLogger,
                    profile: settings.ModelProfile,
                    apiVersion: apiVersion,
                    rateLimitSafetyFactor: settings.ChunkingSettings.RateLimitSafetyFactor);

                logger.LogInformation("ResponsesApiClient initialized for {Model} (API: {ApiVersion})",
                    settings.AISettings.DeploymentName, apiVersion);
            }

            // IChatClient for code agents — used when provider is GitHubCopilot/OpenAI or model doesn't support Responses API
            if (!await PreflightModelsAsync(settings, serviceType, logger))
            {
                Environment.ExitCode = 1;
                return;
            }

            IChatClient codeClient = ChatClientFactory.CreateFromSettings(settings.AISettings, logger: logger);
            logger.LogInformation("Code IChatClient initialized via {Provider} for model: {Model}",
                serviceType, settings.AISettings.ModelId);

            // IChatClient for chat agents
            var chatDeployment = settings.AISettings.ChatDeploymentName ?? settings.AISettings.DeploymentName;
            IChatClient chatClient = ChatClientFactory.CreateChatClientFromSettings(settings.AISettings, logger);
            logger.LogInformation("Chat IChatClient initialized via {Provider} for model: {ChatModel}",
                serviceType, settings.AISettings.ResolveChatModelId());

            var providerName = codeClient is Agents.Infrastructure.CopilotChatClient ? "GitHub Copilot" : "Azure OpenAI";
            var chatLogger = new ChatLogger(loggerFactory.CreateLogger<ChatLogger>(), providerName: providerName);

            var databasePath = settings.ApplicationSettings.MigrationDatabasePath;
            if (!Path.IsPathRooted(databasePath))
            {
                databasePath = Path.GetFullPath(databasePath);
            }

            var migrationRepositoryLogger = loggerFactory.CreateLogger<SqliteMigrationRepository>();
            var sqliteMigrationRepository = new SqliteMigrationRepository(databasePath, migrationRepositoryLogger);
            await sqliteMigrationRepository.InitializeAsync();

            var neo4jMigrationRepository = await Neo4jConnection.TryOpenAsync(settings.ApplicationSettings.Neo4j, loggerFactory, logger);

            var hybridLogger = loggerFactory.CreateLogger<HybridMigrationRepository>();
            var migrationRepository = new HybridMigrationRepository(sqliteMigrationRepository, neo4jMigrationRepository, hybridLogger);
            await migrationRepository.InitializeAsync();

            // Cleanup stale runs on startup
            if (!resume)
            {
                await migrationRepository.CleanupStaleRunsAsync();
            }

            // Holds business logic extracted during reverse engineering to be passed into migration
            ReverseEngineeringResult? reverseEngResultForMigration = null;

            // Step 1: Run reverse engineering if requested (and not skipped)
            if (!skipReverseEngineering || reverseEngineerOnly)
            {
                // EnhancedLogger and ChatLogger already created above for API tracking

                ConfigureSmartChunking(settings, chatDeployment, logger);

                // Create orchestrator early so agents can use it
                var targetLang = settings.ApplicationSettings.TargetLanguage;
                var chunkingOrchestrator = new CobolToQuarkusMigration.Chunking.ChunkingOrchestrator(
                    settings.ChunkingSettings,
                    settings.ConversionSettings,
                    databasePath,
                    loggerFactory.CreateLogger<CobolToQuarkusMigration.Chunking.ChunkingOrchestrator>(),
                    targetLang);

                // Create agents using factory methods — auto-route ResponsesApiClient vs IChatClient
                var cobolAnalyzerAgent = CobolAnalyzerAgent.Create(
                    responsesApiClient, codeClient,
                    loggerFactory.CreateLogger<CobolAnalyzerAgent>(),
                    settings.AISettings.ResolveCobolAnalyzerModelId(),
                    enhancedLogger, chatLogger, settings: settings);

                var businessLogicExtractorAgent = BusinessLogicExtractorAgent.Create(
                    responsesApiClient, chatClient,
                    loggerFactory.CreateLogger<BusinessLogicExtractorAgent>(),
                    settings.AISettings.ResolveChatModelId(),
                    enhancedLogger, chatLogger,
                    chunkingOrchestrator: chunkingOrchestrator, settings: settings);

                var dependencyMapperAgent = DependencyMapperAgent.Create(
                    responsesApiClient, codeClient,
                    loggerFactory.CreateLogger<DependencyMapperAgent>(),
                    settings.AISettings.ResolveDependencyMapperModelId(),
                    enhancedLogger, chatLogger, settings: settings);

                // Smart routing: check for large files to decide between chunked vs direct RE
                var cobolFiles = await fileHelper.ScanDirectoryForCobolFilesAsync(settings.ApplicationSettings.CobolSourceFolder);
                var hasLargeFiles = cobolFiles.Any(f =>
                    settings.ChunkingSettings.RequiresChunking(f.Content.Length, f.Content.Split('\n').Length));

                ReverseEngineeringResult reverseEngResult;

                if (hasLargeFiles)
                {
                    // Use ChunkedReverseEngineeringProcess for large files
                    Console.WriteLine("📦 Large files detected - using smart chunked reverse engineering");
                    logger.LogInformation("Large files detected, using ChunkedReverseEngineeringProcess");

                    // chunkingOrchestrator and targetLang initialized in outer scope

                    var chunkedREProcess = new ChunkedReverseEngineeringProcess(
                        cobolAnalyzerAgent,
                        businessLogicExtractorAgent,
                        dependencyMapperAgent,
                        fileHelper,
                        settings.ChunkingSettings,
                        chunkingOrchestrator,
                        loggerFactory.CreateLogger<ChunkedReverseEngineeringProcess>(),
                        enhancedLogger,
                        databasePath,
                        migrationRepository);

                    reverseEngResult = await chunkedREProcess.RunAsync(
                        settings.ApplicationSettings.CobolSourceFolder,
                        reverseEngineerOutput,
                        (status, current, total) =>
                        {
                            Console.WriteLine($"{status} - {current}/{total}");
                        });
                }
                else
                {
                    // Use standard ReverseEngineeringProcess for small files
                    Console.WriteLine("⚡ All files below chunking threshold - using direct reverse engineering");

                    var reverseEngineeringProcess = new ReverseEngineeringProcess(
                        cobolAnalyzerAgent,
                        businessLogicExtractorAgent,
                        dependencyMapperAgent,
                        fileHelper,
                        loggerFactory.CreateLogger<ReverseEngineeringProcess>(),
                        enhancedLogger,
                        migrationRepository);

                    reverseEngResult = await reverseEngineeringProcess.RunAsync(
                        settings.ApplicationSettings.CobolSourceFolder,
                        reverseEngineerOutput,
                        (status, current, total) =>
                        {
                            Console.WriteLine($"{status} - {current}/{total}");
                        });
                }

                if (!reverseEngResult.Success)
                {
                    logger.LogError("Reverse engineering failed: {Error}", reverseEngResult.ErrorMessage);
                    Environment.Exit(1);
                }

                // Kept for the dependency map; its business logic reaches the prompts only with --reuse-re.
                reverseEngResultForMigration = reverseEngResult;
                if (!reuseRe && !reverseEngineerOnly)
                {
                    Console.WriteLine("ℹ️  Business logic from reverse engineering is saved to the report but not injected into conversion prompts. Pass --reuse-re to inject it.");
                }

                // If reverse-engineer-only mode, exit here
                if (reverseEngineerOnly)
                {
                    Console.WriteLine("Reverse engineering completed successfully. Skipping Java conversion as requested.");
                    return;
                }
            }
            else
            {
                // --skip-reverse-engineering: only load persisted business logic when --reuse-re is also set
                if (reuseRe)
                {
                    // The newest run is not necessarily the one holding reverse-engineering
                    // output: a run terminated before its business logic was persisted leaves a
                    // newer id with nothing behind it, and selecting that silently converted the
                    // whole estate without any business-logic context.
                    var sourceRunId = await migrationRepository.GetLatestRunIdWithBusinessLogicAsync(cobolSource);
                    if (sourceRunId is int reuseRunId)
                    {
                        var savedLogic = await migrationRepository.GetBusinessLogicAsync(reuseRunId);
                        var snapshot = await migrationRepository.SearchCobolFilesAsync(reuseRunId, null);
                        var freshness = BusinessLogicReuse.FilterStale(savedLogic, snapshot, BusinessLogicReuse.ReadFileOrNull);
                        var reuseRun = await migrationRepository.GetRunAsync(reuseRunId);
                        var reuseDate = reuseRun?.StartedAt.ToString("yyyy-MM-dd HH:mm") ?? "unknown date";

                        if (freshness.Changed.Count > 0)
                        {
                            Console.WriteLine($"⚠️  --reuse-re: {freshness.Changed.Count} file(s) changed since Run #{reuseRunId}; their business logic is ignored: {string.Join(", ", freshness.Changed.Take(10))}{(freshness.Changed.Count > 10 ? ", ..." : "")}");
                        }
                        if (freshness.Missing.Count > 0)
                        {
                            logger.LogInformation("--reuse-re: {Count} file(s) from Run #{RunId} are no longer present: {Files}", freshness.Missing.Count, reuseRunId, string.Join(", ", freshness.Missing));
                        }

                        if (freshness.Fresh.Count > 0)
                        {
                            Console.WriteLine($"♻️  Loaded {freshness.Fresh.Count} business logic entries from Run #{reuseRunId} ({reuseDate}).");
                            reverseEngResultForMigration = new ReverseEngineeringResult
                            {
                                Success = true,
                                RunId = reuseRunId,
                                BusinessLogicExtracts = freshness.Fresh
                            };
                        }
                        else
                        {
                            Console.WriteLine($"⚠️  --reuse-re: Run #{reuseRunId} holds no business logic that still matches the source. Migration will proceed without business logic context.");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"⚠️  --reuse-re: no previous run over {cobolSource} has persisted business logic. Run a reverse-engineering pass on this source first, or drop --skip-reverse-engineering. Migration will proceed without business logic context.");
                    }
                }
                else
                {
                    Console.WriteLine("ℹ️  Skipping reverse engineering. Pass --reuse-re to inject business logic from a previous RE run.");
                }
            }

            // Step 2: Run code conversion (unless reverse-engineer-only mode)
            if (!reverseEngineerOnly)
            {
                // Determine output folder based on target language
                var targetLang = settings.ApplicationSettings.TargetLanguage;
                var outputFolder = targetLang == TargetLanguage.CSharp
                    ? settings.ApplicationSettings.CSharpOutputFolder
                    : settings.ApplicationSettings.JavaOutputFolder;

                // Ensure output folder has a default value
                if (string.IsNullOrEmpty(outputFolder))
                {
                    outputFolder = targetLang == TargetLanguage.CSharp ? "output/csharp" : "output/java";
                }

                var langName = targetLang == TargetLanguage.CSharp ? "C# .NET" : "Java Quarkus";

                // ═══════════════════════════════════════════════════════════════════
                // QUALITY GATE: Final verification before migration starts
                // ═══════════════════════════════════════════════════════════════════
                Console.WriteLine("");
                Console.WriteLine("═══════════════════════════════════════════════════════════════════");
                Console.WriteLine("                    🔒 QUALITY GATE: PRE-MIGRATION CHECK");
                Console.WriteLine("═══════════════════════════════════════════════════════════════════");
                Console.WriteLine($"  Target Language:  {langName}");
                Console.WriteLine($"  Output Folder:    {outputFolder}");
                Console.WriteLine($"  ENV Variable:     TARGET_LANGUAGE={Environment.GetEnvironmentVariable("TARGET_LANGUAGE") ?? "(not set)"}");
                Console.WriteLine($"  Smart Chunking:   ENABLED (auto-routes large files)");
                Console.WriteLine($"  Chunk Threshold:  {settings.ChunkingSettings.AutoChunkCharThreshold:N0} chars / {settings.ChunkingSettings.AutoChunkLineThreshold:N0} lines");

                // Verify env var matches what we're about to do
                var envLang = Environment.GetEnvironmentVariable("TARGET_LANGUAGE");
                if (!string.IsNullOrEmpty(envLang))
                {
                    var expectedCSharp = envLang.Equals("CSharp", StringComparison.OrdinalIgnoreCase) ||
                                         envLang.Equals("C#", StringComparison.OrdinalIgnoreCase);
                    var actualCSharp = targetLang == TargetLanguage.CSharp;

                    if (expectedCSharp != actualCSharp)
                    {
                        Console.WriteLine($"  ❌ MISMATCH DETECTED!");
                        Console.WriteLine($"     ENV says: {(expectedCSharp ? "CSharp" : "Java")}");
                        Console.WriteLine($"     Settings say: {targetLang}");
                        Console.WriteLine("═══════════════════════════════════════════════════════════════════");
                        Console.WriteLine("❌ QUALITY GATE FAILED: Language mismatch between env var and settings!");
                        Console.WriteLine("   This indicates a bug in configuration loading. Aborting.");
                        Environment.Exit(1);
                    }
                }

                Console.WriteLine($"  ✅ Quality Gate PASSED");
                Console.WriteLine("═══════════════════════════════════════════════════════════════════");
                Console.WriteLine("");

                Console.WriteLine($"Starting COBOL to {langName} migration with Smart Orchestration...");
                Console.WriteLine($"Target language: {langName}");
                Console.WriteLine($"Output folder: {outputFolder}");

                int? resumeRunId = null;
                if (resume)
                {
                    logger.LogInformation("Resume requested. Fetching latest run...");
                    var latestRun = await migrationRepository.GetLatestRunAsync();
                    if (latestRun != null && latestRun.Status != "Completed")
                    {
                        resumeRunId = latestRun.RunId;
                        logger.LogInformation("Resuming run ID: {RunId} (Status: {Status})", latestRun.RunId, latestRun.Status);
                        Console.WriteLine($"🔄 Resuming from Run ID: {latestRun.RunId}");
                    }
                    else
                    {
                        logger.LogWarning("Resume requested but no active run found. Starting new run.");
                        Console.WriteLine("⚠️  No resumable run found. Starting new run.");
                    }
                }

                // Use SmartMigrationOrchestrator for intelligent file routing
                // - Small files → direct MigrationProcess (fast, no chunking overhead)
                // - Large files → ChunkedMigrationProcess (preserves ALL code, no truncation)
                var smartOrchestrator = new SmartMigrationOrchestrator(
                    responsesApiClient,
                    chatClient,
                    loggerFactory,
                    fileHelper,
                    settings,
                    migrationRepository);

                var migrationStats = await smartOrchestrator.RunAsync(
                    settings.ApplicationSettings.CobolSourceFolder,
                    outputFolder,
                    (status, current, total) =>
                    {
                        Console.WriteLine($"{status} - {current}/{total}");
                    },
                    existingRunId: resumeRunId,
                    // Model-written business logic made converters follow the summary instead of
                    // translating every paragraph (Bank-of-Z), so it is injected only on request.
                    businessLogicExtracts: reuseRe ? reverseEngResultForMigration?.BusinessLogicExtracts : null,
                    existingDependencyMap: reverseEngResultForMigration?.DependencyMap,
                    runType: skipReverseEngineering ? "Conversion Only" : "Full Migration");

                Console.WriteLine("Migration process completed successfully.");
                Console.WriteLine($"  📊 Stats: {migrationStats.TotalFiles} files ({migrationStats.DirectFiles} direct, {migrationStats.ChunkedFiles} chunked)");
                if (migrationStats.TotalChunks > 0)
                {
                    Console.WriteLine($"  📦 Total chunks processed: {migrationStats.TotalChunks}");
                }
            }
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error in migration process");
            Environment.Exit(1);
        }
    }

    private static void LoadEnvironmentVariables()
    {
        try
        {
            string currentDir = Directory.GetCurrentDirectory();
            string configDir = Path.Combine(currentDir, "Config");
            string localConfigFile = Path.Combine(configDir, "ai-config.local.env");

            if (File.Exists(localConfigFile))
            {
                LoadEnvFile(localConfigFile);
            }
            else
            {
                Console.WriteLine("💡 Consider creating Config/ai-config.local.env for your personal settings");
                Console.WriteLine("   You can copy from Config/ai-config.env.example");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ Error loading environment configuration: {ex.Message}");
        }
    }

    private static void LoadEnvFile(string filePath)
    {
        var rawVars = new Dictionary<string, string>();

        foreach (string line in File.ReadAllLines(filePath))
        {
            string trimmedLine = line.Trim();
            if (string.IsNullOrEmpty(trimmedLine) || trimmedLine.StartsWith('#'))
                continue;

            var parts = trimmedLine.Split('=', 2);
            if (parts.Length == 2)
            {
                string key = parts[0].Trim();
                string value = parts[1].Trim().Trim('"', '\'');

                // Store raw value first
                rawVars[key] = value;

                // Variable Expansion (Basic)
                // If value contains $VAR or ${VAR}, try to replace from ALREADY loaded Env vars or current file dictionary
                if (value.Contains('$'))
                {
                    value = ExpandVariables(value, rawVars);
                }

                // CRITICAL: Do NOT overwrite environment variables that are already set
                var existingValue = Environment.GetEnvironmentVariable(key);
                if (string.IsNullOrEmpty(existingValue))
                {
                    Environment.SetEnvironmentVariable(key, value);
                }
                else if (key == "TARGET_LANGUAGE")
                {
                    Console.WriteLine($"🔒 Preserving TARGET_LANGUAGE from shell: '{existingValue}' (ignoring config file value: '{value}')");
                }
            }
        }
    }

    private static string ExpandVariables(string value, Dictionary<string, string> fileVars)
    {
        // Simple expansion: find $VAR or ${VAR}
        // This is not a full bash emulator but handles common cases
        // We iterate specifically looking for keys we might know

        // 1. Check fileVars (local scope first)
        foreach (var kvp in fileVars)
        {
            value = value.Replace($"${{{kvp.Key}}}", kvp.Value)
                         .Replace($"${kvp.Key}", kvp.Value);
        }

        // 2. Check Environment (global scope)
        // We don't iterate all env vars (too many), but we could use regex to find substitutions
        // For now, let's just handle simple known variable patterns if needed, 
        // but typically users only reference vars defined earlier in the SAME file or standard ones.
        return value;
    }

    internal static void OverrideSettingsFromEnvironment(AppSettings settings)
    {
        var aiSettings = settings.AISettings ??= new AISettings();
        var applicationSettings = settings.ApplicationSettings ??= new ApplicationSettings();

        // Service type (provider selection)
        var serviceType = Environment.GetEnvironmentVariable("AZURE_OPENAI_SERVICE_TYPE");
        if (!string.IsNullOrEmpty(serviceType))
        {
            aiSettings.ServiceType = serviceType;
        }

        // GitHubCopilot and GitHubCopilotSDK both run on the Copilot SDK, which signs in through
        // CopilotAuth and uses neither endpoint nor API key. GITHUB_TOKEN is deliberately not copied
        // into ApiKey: doing so turned an Azure Entra ID setup into key auth with a GitHub token.
        if (aiSettings.ServiceType.Equals("GitHubCopilot", StringComparison.OrdinalIgnoreCase) ||
            aiSettings.ServiceType.Equals("GitHubCopilotSDK", StringComparison.OrdinalIgnoreCase))
        {
            if (string.IsNullOrEmpty(aiSettings.Endpoint))
            {
                aiSettings.Endpoint = "copilot-sdk://cli";
            }
        }

        // Primary deployment (for code models)
        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
        if (!string.IsNullOrEmpty(endpoint))
        {
            aiSettings.Endpoint = endpoint;
        }

        var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
        if (!string.IsNullOrEmpty(apiKey))
        {
            aiSettings.ApiKey = apiKey;
        }

        var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME");
        if (!string.IsNullOrEmpty(deploymentName))
        {
            aiSettings.DeploymentName = deploymentName;
        }

        var modelId = Environment.GetEnvironmentVariable("AZURE_OPENAI_MODEL_ID");
        if (!string.IsNullOrEmpty(modelId))
        {
            aiSettings.ModelId = modelId;
        }

        // Chat deployment (for gpt-5.1-chat models via Chat Completions API)
        var chatEndpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_CHAT_ENDPOINT");
        if (!string.IsNullOrEmpty(chatEndpoint))
        {
            aiSettings.ChatEndpoint = chatEndpoint;
        }

        var chatApiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_CHAT_API_KEY");
        if (!string.IsNullOrEmpty(chatApiKey))
        {
            aiSettings.ChatApiKey = chatApiKey;
        }

        // The chat client prefers a non-empty chat endpoint over the main one, so the template
        // value left in appsettings.json would win over a real endpoint set only for code models.
        if (!string.IsNullOrEmpty(aiSettings.ChatEndpoint) && IsTemplatePlaceholder(aiSettings.ChatEndpoint))
        {
            aiSettings.ChatEndpoint = string.Empty;
        }
        if (!string.IsNullOrEmpty(aiSettings.ChatApiKey) && IsTemplatePlaceholder(aiSettings.ChatApiKey))
        {
            aiSettings.ChatApiKey = string.Empty;
        }

        var chatDeploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_CHAT_DEPLOYMENT_NAME");
        if (!string.IsNullOrEmpty(chatDeploymentName))
        {
            aiSettings.ChatDeploymentName = chatDeploymentName;
        }

        var chatModelId = Environment.GetEnvironmentVariable("AZURE_OPENAI_CHAT_MODEL_ID");
        if (!string.IsNullOrEmpty(chatModelId))
        {
            aiSettings.ChatModelId = chatModelId;
        }

        // Specialized model IDs
        var cobolModel = Environment.GetEnvironmentVariable("AZURE_OPENAI_COBOL_ANALYZER_MODEL");
        if (!string.IsNullOrEmpty(cobolModel))
        {
            aiSettings.CobolAnalyzerModelId = cobolModel;
        }

        var javaModel = Environment.GetEnvironmentVariable("AZURE_OPENAI_JAVA_CONVERTER_MODEL");
        if (!string.IsNullOrEmpty(javaModel))
        {
            aiSettings.JavaConverterModelId = javaModel;
        }

        var depModel = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPENDENCY_MAPPER_MODEL");
        if (!string.IsNullOrEmpty(depModel))
        {
            aiSettings.DependencyMapperModelId = depModel;
        }

        var testModel = Environment.GetEnvironmentVariable("AZURE_OPENAI_UNIT_TEST_MODEL");
        if (!string.IsNullOrEmpty(testModel))
        {
            aiSettings.UnitTestModelId = testModel;
        }

        // Context Window Override (Explicitly set context size to avoid magic string detection)
        var contextWindowSize = Environment.GetEnvironmentVariable("AZURE_OPENAI_CONTEXT_WINDOW_SIZE");
        if (!string.IsNullOrEmpty(contextWindowSize) && int.TryParse(contextWindowSize, out int size))
        {
            aiSettings.ContextWindowSize = size;
        }

        if (Environment.GetEnvironmentVariable("COBOL_SOURCE_FOLDER") is { Length: > 0 } cobolSource)
        {
            applicationSettings.CobolSourceFolder = cobolSource;
        }

        if (Environment.GetEnvironmentVariable("JAVA_OUTPUT_FOLDER") is { Length: > 0 } javaOutput)
        {
            applicationSettings.JavaOutputFolder = javaOutput;
        }

        // doctor.sh exports these from Config/ai-config.local.env; the portal binds the same names
        // through ASP.NET configuration, so both processes reach the same graph.
        if (applicationSettings.Neo4j is { } neo4j)
        {
            if (Environment.GetEnvironmentVariable("ApplicationSettings__Neo4j__Uri") is { Length: > 0 } neo4jUri)
            {
                neo4j.Uri = neo4jUri;
            }
            if (Environment.GetEnvironmentVariable("ApplicationSettings__Neo4j__Password") is { Length: > 0 } neo4jPassword)
            {
                neo4j.Password = neo4jPassword;
            }
        }

        if (Environment.GetEnvironmentVariable("TEST_OUTPUT_FOLDER") is { Length: > 0 } testOutput)
        {
            applicationSettings.TestOutputFolder = testOutput;
        }

        if (Environment.GetEnvironmentVariable("MIGRATION_DB_PATH") is { Length: > 0 } migrationDb)
        {
            applicationSettings.MigrationDatabasePath = migrationDb;
        }

        // Target language selection (from doctor.sh or config file)
        if (Environment.GetEnvironmentVariable("TARGET_LANGUAGE") is { Length: > 0 } targetLang)
        {
            var trimmedLang = targetLang.Trim();
            var isCSharp = trimmedLang.Equals("CSharp", StringComparison.OrdinalIgnoreCase) ||
                           trimmedLang.Equals("C#", StringComparison.OrdinalIgnoreCase);
            applicationSettings.TargetLanguage = isCSharp ? TargetLanguage.CSharp : TargetLanguage.Java;

            // Quality Gate: Verify the language was correctly parsed
            Console.WriteLine($"🎯 TARGET_LANGUAGE env var: '{trimmedLang}' → {applicationSettings.TargetLanguage}");
            Console.WriteLine($"🔒 Quality Gate: Language selection = {applicationSettings.TargetLanguage}");

            // Additional verification: Check if the env var value matches expected values
            if (!trimmedLang.Equals("Java", StringComparison.OrdinalIgnoreCase) &&
                !trimmedLang.Equals("CSharp", StringComparison.OrdinalIgnoreCase) &&
                !trimmedLang.Equals("C#", StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine($"⚠️  WARNING: TARGET_LANGUAGE='{trimmedLang}' is not a recognized value.");
                Console.WriteLine($"   Expected: 'Java' or 'CSharp'. Falling back to: {applicationSettings.TargetLanguage}");
            }
        }
        else
        {
            Console.WriteLine($"🎯 TARGET_LANGUAGE env var not set, using config default: {applicationSettings.TargetLanguage}");
        }

        // C# output folder (separate from Java output)
        if (Environment.GetEnvironmentVariable("CSHARP_OUTPUT_FOLDER") is { Length: > 0 } csharpOutput)
        {
            applicationSettings.CSharpOutputFolder = csharpOutput;
        }

        // ── Model Profile Overrides (Three-Tier Reasoning) ──────────────────

        // Model Profile overrides (applies to all model families)
        var modelProfile = settings.ModelProfile ??= new ModelProfileSettings();

        if (Environment.GetEnvironmentVariable("AI_LOW_REASONING_EFFORT") is { Length: > 0 } aiLowEffort)
            modelProfile.LowReasoningEffort = aiLowEffort;
        if (Environment.GetEnvironmentVariable("AI_MEDIUM_REASONING_EFFORT") is { Length: > 0 } aiMedEffort)
            modelProfile.MediumReasoningEffort = aiMedEffort;
        if (Environment.GetEnvironmentVariable("AI_HIGH_REASONING_EFFORT") is { Length: > 0 } aiHighEffort)
            modelProfile.HighReasoningEffort = aiHighEffort;

        if (Environment.GetEnvironmentVariable("AI_MEDIUM_THRESHOLD") is { Length: > 0 } aiMedThresh
            && int.TryParse(aiMedThresh, out var cmtVal))
            modelProfile.MediumThreshold = cmtVal;
        if (Environment.GetEnvironmentVariable("AI_HIGH_THRESHOLD") is { Length: > 0 } aiHighThresh
            && int.TryParse(aiHighThresh, out var chtVal))
            modelProfile.HighThreshold = chtVal;

        if (Environment.GetEnvironmentVariable("AI_LOW_MULTIPLIER") is { Length: > 0 } aiLowMult
            && double.TryParse(aiLowMult, NumberStyles.Float, CultureInfo.InvariantCulture, out var clmVal))
            modelProfile.LowMultiplier = clmVal;
        if (Environment.GetEnvironmentVariable("AI_MEDIUM_MULTIPLIER") is { Length: > 0 } aiMedMult
            && double.TryParse(aiMedMult, NumberStyles.Float, CultureInfo.InvariantCulture, out var cmmVal))
            modelProfile.MediumMultiplier = cmmVal;
        if (Environment.GetEnvironmentVariable("AI_HIGH_MULTIPLIER") is { Length: > 0 } aiHighMult
            && double.TryParse(aiHighMult, NumberStyles.Float, CultureInfo.InvariantCulture, out var chmVal))
            modelProfile.HighMultiplier = chmVal;

        if (Environment.GetEnvironmentVariable("AI_MIN_OUTPUT_TOKENS") is { Length: > 0 } aiMinTokens
            && int.TryParse(aiMinTokens, out var cminVal))
            modelProfile.MinOutputTokens = cminVal;
        if (Environment.GetEnvironmentVariable("AI_MAX_OUTPUT_TOKENS") is { Length: > 0 } aiMaxTokens
            && int.TryParse(aiMaxTokens, out var cmaxVal))
            modelProfile.MaxOutputTokens = cmaxVal;

        if (Environment.GetEnvironmentVariable("AI_TIMEOUT_SECONDS") is { Length: > 0 } aiTimeout
            && int.TryParse(aiTimeout, out var ctVal))
            modelProfile.TimeoutSeconds = ctVal;
        if (Environment.GetEnvironmentVariable("AI_TOKENS_PER_MINUTE") is { Length: > 0 } aiTpm
            && int.TryParse(aiTpm, out var ctpmVal))
            modelProfile.TokensPerMinute = ctpmVal;
        if (Environment.GetEnvironmentVariable("AI_REQUESTS_PER_MINUTE") is { Length: > 0 } aiRpm
            && int.TryParse(aiRpm, out var crpmVal))
            modelProfile.RequestsPerMinute = crpmVal;

        if (Environment.GetEnvironmentVariable("AI_PIC_DENSITY_FLOOR") is { Length: > 0 } aiPicFloor
            && double.TryParse(aiPicFloor, NumberStyles.Float, CultureInfo.InvariantCulture, out var cpfVal))
            modelProfile.PicDensityFloor = cpfVal;
        if (Environment.GetEnvironmentVariable("AI_LEVEL_DENSITY_FLOOR") is { Length: > 0 } aiLevelFloor
            && double.TryParse(aiLevelFloor, NumberStyles.Float, CultureInfo.InvariantCulture, out var clfVal))
            modelProfile.LevelDensityFloor = clfVal;

        if (Environment.GetEnvironmentVariable("AI_ENABLE_AMPLIFIERS") is { Length: > 0 } aiAmps
            && bool.TryParse(aiAmps, out var caVal))
            modelProfile.EnableAmplifiers = caVal;

        if (Environment.GetEnvironmentVariable("AI_EXHAUSTION_MAX_RETRIES") is { Length: > 0 } aiExRetries
            && int.TryParse(aiExRetries, out var cerVal))
            modelProfile.ReasoningExhaustionMaxRetries = cerVal;
        if (Environment.GetEnvironmentVariable("AI_EXHAUSTION_RETRY_MULTIPLIER") is { Length: > 0 } aiExMult
            && double.TryParse(aiExMult, NumberStyles.Float, CultureInfo.InvariantCulture, out var cemVal))
            modelProfile.ReasoningExhaustionRetryMultiplier = cemVal;

        // The prompt injector is static and reads the environment, so the effective JCL job
        // settings are published there once the overrides are applied.
        var jclJobs = settings.JclJobs ??= new JclJobsSettings();
        if (Environment.GetEnvironmentVariable(CobolToQuarkusMigration.Jcl.Generation.JclBatchPrograms.EnabledVariable) is { Length: > 0 } jclEnabled)
            jclJobs.Enabled = !string.Equals(jclEnabled.Trim(), "false", StringComparison.OrdinalIgnoreCase);
        if (Environment.GetEnvironmentVariable(CobolToQuarkusMigration.Jcl.Generation.JclBatchPrograms.SourceVariable) is { Length: > 0 } jclSource)
            jclJobs.SourceFolder = jclSource;
        Environment.SetEnvironmentVariable(CobolToQuarkusMigration.Jcl.Generation.JclBatchPrograms.EnabledVariable, jclJobs.Enabled ? "true" : "false");
        if (!string.IsNullOrWhiteSpace(jclJobs.SourceFolder))
            Environment.SetEnvironmentVariable(CobolToQuarkusMigration.Jcl.Generation.JclBatchPrograms.SourceVariable, jclJobs.SourceFolder);

        var compileGate = settings.CompileGate ??= new CompileGateSettings();
        if (Environment.GetEnvironmentVariable("COMPILE_REPAIR_MAX_ROUNDS") is { Length: > 0 } repairRounds
            && int.TryParse(repairRounds, out var rrVal) && rrVal >= 0)
            compileGate.MaxRepairRounds = rrVal;

        // ── Speed-profile overrides for ChunkingSettings ────────────────────
        var chunkingSettings = settings.ChunkingSettings ??= new ChunkingSettings();

        if (Environment.GetEnvironmentVariable("AI_STAGGER_DELAY_MS") is { Length: > 0 } staggerMs
            && int.TryParse(staggerMs, out var sVal))
            chunkingSettings.ParallelStaggerDelayMs = sVal;
        if (Environment.GetEnvironmentVariable("AI_MAX_PARALLEL_CONVERSION") is { Length: > 0 } maxParConv
            && int.TryParse(maxParConv, out var mpcVal))
            chunkingSettings.MaxParallelConversion = mpcVal;
        if (Environment.GetEnvironmentVariable("AI_MAX_PARALLEL_ANALYSIS") is { Length: > 0 } maxParAna
            && int.TryParse(maxParAna, out var mpaVal))
            chunkingSettings.MaxParallelAnalysis = mpaVal;
        if (Environment.GetEnvironmentVariable("AI_MAX_PARALLEL_CHUNKS") is { Length: > 0 } maxParChk
            && int.TryParse(maxParChk, out var mpchVal))
            chunkingSettings.MaxParallelChunks = mpchVal;
        if (Environment.GetEnvironmentVariable("AI_RATE_LIMIT_SAFETY_FACTOR") is { Length: > 0 } safetyFactor
            && double.TryParse(safetyFactor, NumberStyles.Float, CultureInfo.InvariantCulture, out var sfVal))
            chunkingSettings.RateLimitSafetyFactor = sfVal;

        // Chat Profile overrides (subset — chat profiles are simpler)
        var chatProfile = settings.ChatProfile ??= new ModelProfileSettings();

        if (Environment.GetEnvironmentVariable("CHAT_TIMEOUT_SECONDS") is { Length: > 0 } chatTimeout
            && int.TryParse(chatTimeout, out var chatTVal))
            chatProfile.TimeoutSeconds = chatTVal;
        if (Environment.GetEnvironmentVariable("CHAT_TOKENS_PER_MINUTE") is { Length: > 0 } chatTpm
            && int.TryParse(chatTpm, out var chatTpmVal))
            chatProfile.TokensPerMinute = chatTpmVal;
        if (Environment.GetEnvironmentVariable("CHAT_MIN_OUTPUT_TOKENS") is { Length: > 0 } chatMinTokens
            && int.TryParse(chatMinTokens, out var chatMinVal))
            chatProfile.MinOutputTokens = chatMinVal;
        if (Environment.GetEnvironmentVariable("CHAT_MAX_OUTPUT_TOKENS") is { Length: > 0 } chatMaxTokens
            && int.TryParse(chatMaxTokens, out var chatMaxVal))
            chatProfile.MaxOutputTokens = chatMaxVal;
    }

    // These subcommands only read and write files, or run before configuration exists at all.
    // Requiring AI credentials for them was masked while Config/ai-config.env shipped
    // placeholder values that satisfied validation.
    internal static bool RequiresAiSettings(string[] args)
    {
        if (args.Any(a => a is "--help" or "-h" or "-?" or "--version"))
        {
            return false;
        }

        var command = args.FirstOrDefault(a => !a.StartsWith('-'));

        // doctor.sh calls list-models during setup to populate the model picker, before any
        // config file has been written; its handler talks to the Copilot SDK, not Azure.
        return command is not
            ("program-facts" or "rekt-scan-cache" or "conversation" or "list-models" or "estate-graph");
    }

    // Matched against the literals shipped in ai-config.env.example. An unedited placeholder that
    // passes validation resurfaces as a DNS or auth failure, not as "you have not configured this".
    private static bool IsTemplatePlaceholder(string value) =>
        value.Contains("your-endpoint", StringComparison.OrdinalIgnoreCase) ||
        value.Contains("your-resource", StringComparison.OrdinalIgnoreCase) ||
        value.Contains("your-api-key", StringComparison.OrdinalIgnoreCase) ||
        value.Contains("placeholder", StringComparison.OrdinalIgnoreCase);

    private static bool ValidateAndLoadConfiguration(bool requireAiSettings)
    {
        try
        {
            LoadEnvironmentVariables();

            if (!requireAiSettings)
            {
                return true;
            }

            var serviceType = Environment.GetEnvironmentVariable("AZURE_OPENAI_SERVICE_TYPE");
            if (string.IsNullOrWhiteSpace(serviceType)) serviceType = "AzureOpenAI";
            serviceType = serviceType.Trim();

            // ChatClientFactory routes both "GitHubCopilot" and "GitHubCopilotSDK" to the Copilot
            // SDK, which signs in with copilot login or COPILOT_GITHUB_TOKEN (see CopilotAuth), so
            // neither needs an API key here.
            var isGitHubCopilotSdk = serviceType.Equals("GitHubCopilotSDK", StringComparison.OrdinalIgnoreCase) ||
                                     serviceType.Equals("GitHubCopilot", StringComparison.OrdinalIgnoreCase);
            var isDirectOpenAI = serviceType.Equals("OpenAI", StringComparison.OrdinalIgnoreCase);
            var isAzure = serviceType.Equals("AzureOpenAI", StringComparison.OrdinalIgnoreCase);

            var requiredSettings = new Dictionary<string, string?>();
            var invalidSettings = new List<string>();

            if (!isGitHubCopilotSdk && !isDirectOpenAI && !isAzure)
            {
                // "GitHub"/"GitHubModels" used to pass here and then fail inside ChatClientFactory;
                // there is no GitHub Models client.
                invalidSettings.Add(
                    $"AZURE_OPENAI_SERVICE_TYPE '{serviceType}' is not supported. Use AzureOpenAI, GitHubCopilot or OpenAI.");
            }

            if (isGitHubCopilotSdk)
            {
                // GitHub Copilot SDK: only needs model ID, authentication handled by CLI
                requiredSettings["AZURE_OPENAI_MODEL_ID"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_MODEL_ID");
            }
            else if (isDirectOpenAI)
            {
                // Direct OpenAI: needs API key and model
                requiredSettings["AZURE_OPENAI_API_KEY"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
                requiredSettings["AZURE_OPENAI_MODEL_ID"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_MODEL_ID");
            }
            else
            {
                // Azure OpenAI: needs endpoint, deployment, model
                requiredSettings["AZURE_OPENAI_ENDPOINT"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
                requiredSettings["AZURE_OPENAI_DEPLOYMENT_NAME"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME");
                requiredSettings["AZURE_OPENAI_MODEL_ID"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_MODEL_ID");
            }

            // API Key is optional for Azure if using Entra ID
            var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
            if (isAzure)
            {
                if (!string.IsNullOrWhiteSpace(apiKey) && !apiKey.Contains("your-api-key") && !apiKey.Contains("placeholder"))
                {
                    // Key provided and looks valid
                }
                else
                {
                    Console.WriteLine("ℹ️  No valid API Key found. Assuming Microsoft Entra ID (DefaultAzureCredential) authentication.");
                }
            }

            var missingSettings = new List<string>();

            foreach (var setting in requiredSettings)
            {
                if (string.IsNullOrWhiteSpace(setting.Value))
                {
                    missingSettings.Add(setting.Key);
                }
                else
                {
                    if (setting.Key == "AZURE_OPENAI_ENDPOINT" && !Uri.TryCreate(setting.Value, UriKind.Absolute, out _))
                    {
                        invalidSettings.Add($"{setting.Key} (invalid URL format)");
                    }
                    else if (setting.Key == "AZURE_OPENAI_API_KEY" && IsTemplatePlaceholder(setting.Value))
                    {
                        invalidSettings.Add($"{setting.Key} (contains template placeholder)");
                    }
                    else if (setting.Key == "AZURE_OPENAI_ENDPOINT" && IsTemplatePlaceholder(setting.Value))
                    {
                        invalidSettings.Add($"{setting.Key} (contains template placeholder)");
                    }
                }
            }

            if (isGitHubCopilotSdk)
            {
                try
                {
                    var auth = CobolToQuarkusMigration.Agents.Infrastructure.CopilotAuth.Resolve();
                    Console.WriteLine($"🔐 GitHub Copilot auth: {auth.Description}");
                }
                catch (InvalidOperationException ex)
                {
                    invalidSettings.Add(ex.Message);
                }
            }

            if (missingSettings.Any() || invalidSettings.Any())
            {
                Console.WriteLine("❌ Configuration Validation Failed");
                Console.WriteLine("=====================================");

                if (missingSettings.Any())
                {
                    Console.WriteLine("Missing required settings:");
                    foreach (var setting in missingSettings)
                    {
                        Console.WriteLine($"  • {setting}");
                    }

                    Console.WriteLine();
                }

                if (invalidSettings.Any())
                {
                    Console.WriteLine("Invalid settings detected:");
                    foreach (var setting in invalidSettings)
                    {
                        Console.WriteLine($"  • {setting}");
                    }

                    Console.WriteLine();
                }

                Console.WriteLine("Configuration Setup Instructions:");
                Console.WriteLine("1. Run: ./doctor.sh setup (for interactive setup)");
                Console.WriteLine("2. Or manually copy Config/ai-config.env.example to Config/ai-config.local.env");
                Console.WriteLine("3. Edit Config/ai-config.local.env with your actual Azure OpenAI credentials");
                Console.WriteLine("4. Ensure your model deployment names match your Azure OpenAI setup");
                Console.WriteLine();
                Console.WriteLine("For detailed instructions, see the Configuration Reference in README.md");

                return false;
            }

            var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
            var modelId = Environment.GetEnvironmentVariable("AZURE_OPENAI_MODEL_ID");
            var deployment = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME");

            Console.WriteLine($"✅ Configuration Validation Successful ({serviceType})");
            Console.WriteLine("=====================================");
            Console.WriteLine($"Provider: {serviceType}");
            if (!string.IsNullOrEmpty(endpoint))
                Console.WriteLine($"Endpoint: {endpoint}");
            Console.WriteLine($"Model: {modelId}");
            if (!string.IsNullOrEmpty(deployment))
                Console.WriteLine($"Deployment: {deployment}");
            if (!string.IsNullOrEmpty(apiKey) && apiKey.Length > 8)
                Console.WriteLine($"API Key: {apiKey.Substring(0, Math.Min(8, apiKey.Length))}... ({apiKey.Length} chars)");
            Console.WriteLine();

            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ Error during configuration validation: {ex.Message}");
            Console.WriteLine("Please check your configuration files and try again.");
            return false;
        }
    }

    /// <summary>
    /// Returns true when the AI provider is 'GitHubCopilotSDK', meaning we use the
    /// GitHub Copilot SDK (CLI/stdio) instead of a REST API.
    /// </summary>
    private static bool IsGitHubCopilotSdkMode()
    {
        var serviceType = Environment.GetEnvironmentVariable("AZURE_OPENAI_SERVICE_TYPE") ?? "AzureOpenAI";
        return serviceType.Equals("GitHubCopilotSDK", StringComparison.OrdinalIgnoreCase);
    }

    private static async Task RunReverseEngineeringAsync(ILoggerFactory loggerFactory, FileHelper fileHelper, SettingsHelper settingsHelper, string cobolSource, string output, string configPath)
    {
        var logger = loggerFactory.CreateLogger("ReverseEngineering");

        try
        {
            logger.LogInformation("Loading settings from {ConfigPath}", configPath);
            AppSettings? loadedSettings = await settingsHelper.LoadSettingsAsync<AppSettings>(configPath);
            var settings = loadedSettings ?? new AppSettings();

            LoadEnvironmentVariables();
            OverrideSettingsFromEnvironment(settings);

            // Initialize Repositories
            var databasePath = settings.ApplicationSettings.MigrationDatabasePath ?? "Data/migration.db";
            if (!Path.IsPathRooted(databasePath))
            {
                databasePath = Path.GetFullPath(databasePath);
            }

            var repositoryLogger = loggerFactory.CreateLogger<SqliteMigrationRepository>();
            var migrationRepository = new SqliteMigrationRepository(databasePath, repositoryLogger);
            await migrationRepository.InitializeAsync();

            // Override with CLI arguments
            if (!string.IsNullOrEmpty(cobolSource))
            {
                settings.ApplicationSettings.CobolSourceFolder = cobolSource;
            }

            if (string.IsNullOrEmpty(settings.ApplicationSettings.CobolSourceFolder))
            {
                logger.LogError("COBOL source folder not specified. Use --source option.");
                Environment.Exit(1);
            }

            if (string.IsNullOrEmpty(settings.AISettings.Endpoint) &&
                !settings.AISettings.ServiceType.Equals("GitHubCopilot", StringComparison.OrdinalIgnoreCase) &&
                !settings.AISettings.ServiceType.Equals("GitHubCopilotSDK", StringComparison.OrdinalIgnoreCase) &&
                !settings.AISettings.ServiceType.Equals("OpenAI", StringComparison.OrdinalIgnoreCase))
            {
                logger.LogError("AI configuration incomplete. Set endpoint for AzureOpenAI, or use ServiceType=GitHubCopilot/GitHubCopilotSDK.");
                Environment.Exit(1);
            }

            // Create EnhancedLogger early for API tracking
            var enhancedLogger = new EnhancedLogger(
                loggerFactory.CreateLogger<EnhancedLogger>());

            // Get API version from environment or default
            var apiVersion = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_VERSION") ?? "2025-04-01-preview";

            // Create AI clients based on provider
            var reServiceType = settings.AISettings.ServiceType ?? "AzureOpenAI";
            var reCodeModelCaps = CobolToQuarkusMigration.Models.ModelCapabilities.Detect(settings.AISettings.ModelId);

            ResponsesApiClient? responsesApiClient = null;
            if (!IsGitHubCopilotSdkMode() &&
                reServiceType.Equals("AzureOpenAI", StringComparison.OrdinalIgnoreCase) &&
                reCodeModelCaps.SupportsResponsesApi &&
                !string.IsNullOrEmpty(settings.AISettings.Endpoint) &&
                !string.IsNullOrEmpty(settings.AISettings.DeploymentName))
            {
                responsesApiClient = new ResponsesApiClient(
                    settings.AISettings.Endpoint,
                    string.Empty,
                    settings.AISettings.DeploymentName,
                    loggerFactory.CreateLogger<ResponsesApiClient>(),
                    enhancedLogger,
                    profile: settings.ModelProfile,
                    apiVersion: apiVersion,
                    rateLimitSafetyFactor: settings.ChunkingSettings.RateLimitSafetyFactor);

                logger.LogInformation("ResponsesApiClient initialized for {Model} (API: {ApiVersion})",
                    settings.AISettings.DeploymentName, apiVersion);
            }

            // Create IChatClient for all models
            if (!await PreflightModelsAsync(settings, reServiceType, logger))
            {
                Environment.ExitCode = 1;
                return;
            }

            IChatClient codeClient = ChatClientFactory.CreateFromSettings(settings.AISettings, logger: logger);
            var chatDeployment = settings.AISettings.ChatDeploymentName ?? settings.AISettings.DeploymentName;
            IChatClient chatClient = ChatClientFactory.CreateChatClientFromSettings(settings.AISettings, logger);
            logger.LogInformation("AI clients initialized via {Provider}", reServiceType);

            var providerName = codeClient is Agents.Infrastructure.CopilotChatClient ? "GitHub Copilot" : "Azure OpenAI";
            var chatLogger = new ChatLogger(loggerFactory.CreateLogger<ChatLogger>(), providerName: providerName);

            ConfigureSmartChunking(settings, chatDeployment, logger);

            // Create orchestrator early so agents can use it
            var targetLang = settings.ApplicationSettings.TargetLanguage;
            var chunkingOrchestrator = new CobolToQuarkusMigration.Chunking.ChunkingOrchestrator(
                settings.ChunkingSettings,
                settings.ConversionSettings,
                databasePath,
                loggerFactory.CreateLogger<CobolToQuarkusMigration.Chunking.ChunkingOrchestrator>(),
                targetLang);

            // Create agents using factory methods — auto-route ResponsesApiClient vs IChatClient
            var cobolAnalyzerAgent = CobolAnalyzerAgent.Create(
                responsesApiClient, codeClient,
                loggerFactory.CreateLogger<CobolAnalyzerAgent>(),
                settings.AISettings.ResolveCobolAnalyzerModelId(),
                enhancedLogger, chatLogger, settings: settings);

            var businessLogicExtractorAgent = BusinessLogicExtractorAgent.Create(
                responsesApiClient, chatClient,
                loggerFactory.CreateLogger<BusinessLogicExtractorAgent>(),
                settings.AISettings.ResolveChatModelId(),
                enhancedLogger, chatLogger,
                chunkingOrchestrator: chunkingOrchestrator, settings: settings);

            var dependencyMapperAgent = DependencyMapperAgent.Create(
                responsesApiClient, codeClient,
                loggerFactory.CreateLogger<DependencyMapperAgent>(),
                settings.AISettings.ResolveDependencyMapperModelId(),
                enhancedLogger, chatLogger, settings: settings);

            // Smart routing: check for large files to decide between chunked vs direct RE
            var cobolFiles = await fileHelper.ScanDirectoryForCobolFilesAsync(settings.ApplicationSettings.CobolSourceFolder);
            var hasLargeFiles = cobolFiles.Any(f =>
                settings.ChunkingSettings.RequiresChunking(f.Content.Length, f.Content.Split('\n').Length));

            ReverseEngineeringResult result;

            if (hasLargeFiles)
            {
                // Use ChunkedReverseEngineeringProcess for large files
                Console.WriteLine("📦 Large files detected - using smart chunked reverse engineering");
                logger.LogInformation("Large files detected, using ChunkedReverseEngineeringProcess");

                // chunkingOrchestrator created in outer scope

                var chunkedProcess = new ChunkedReverseEngineeringProcess(
                    cobolAnalyzerAgent,
                    businessLogicExtractorAgent,
                    dependencyMapperAgent,
                    fileHelper,
                    settings.ChunkingSettings,
                    chunkingOrchestrator,
                    loggerFactory.CreateLogger<ChunkedReverseEngineeringProcess>(),
                    enhancedLogger,
                    databasePath);

                result = await chunkedProcess.RunAsync(
                    settings.ApplicationSettings.CobolSourceFolder,
                    output,
                    (status, current, total) => Console.WriteLine($"{status} - {current}/{total}"));
            }
            else
            {
                // Use standard ReverseEngineeringProcess with agents
                var reverseEngineeringProcess = new ReverseEngineeringProcess(
                    cobolAnalyzerAgent,
                    businessLogicExtractorAgent,
                    dependencyMapperAgent,
                    fileHelper,
                    loggerFactory.CreateLogger<ReverseEngineeringProcess>(),
                    enhancedLogger,
                    migrationRepository);

                Console.WriteLine("Starting reverse engineering process...");
                Console.WriteLine();

                result = await reverseEngineeringProcess.RunAsync(
                    settings.ApplicationSettings.CobolSourceFolder,
                    output,
                    (status, current, total) =>
                    {
                        Console.WriteLine($"{status} - {current}/{total}");
                    });
            }

            Console.WriteLine();
            Console.WriteLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Console.WriteLine("✨ Reverse Engineering Complete!");
            Console.WriteLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Console.WriteLine();
            Console.WriteLine($"📊 Summary:");
            Console.WriteLine($"   • Files Analyzed: {result.TotalFilesAnalyzed}");
            Console.WriteLine($"   • Feature Descriptions: {result.TotalUserStories}");
            Console.WriteLine($"   • Features: {result.TotalFeatures}");
            Console.WriteLine($"   • Business Rules: {result.TotalBusinessRules}");
            Console.WriteLine();
            Console.WriteLine($"📁 Output Location: {Path.GetFullPath(output)}");
            Console.WriteLine("   • reverse-engineering-details.md - Complete analysis with business logic and technical details");
            Console.WriteLine();
            Console.WriteLine("🎯 Next Steps:");
            Console.WriteLine("   1. Review the generated documentation");
            Console.WriteLine("   2. Decide on your modernization strategy");
            Console.WriteLine("   3. Run full migration if desired: dotnet run --source <path> --java-output <path>");
            Console.WriteLine();
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error during reverse engineering");
            Environment.Exit(1);
        }
    }
    // A selection arrives as one comma-separated value so it survives being passed through a shell,
    // a container argument list and the portal's process launcher without quoting rules differing
    // at each step.
    private static IReadOnlyList<string> SplitPrograms(string value) =>
        value.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

}