feat: enhance progress bar with detailed status display

- Show spinner, progress bar, file count, elapsed/remaining time, and current file
- Update total count dynamically when new files discovered with recursive unpacking
- Fix negative remaining time calculation
- Pass current filename through progress callback for display

Author: Houmgaor

ReFrontier/Orchestration/ApplicationOrchestrator.cs

@@ -153,38 +153,49 @@ private ProcessingStatistics ProcessDirectoryWithProgress(string directoryPath,
                     .AutoClear(false)
                     .HideCompleted(false)
                     .Columns(
-                        new TaskDescriptionColumn(),
+                        new SpinnerColumn(),
                         new ProgressBarColumn(),
-                        new PercentageColumn(),
-                        new ElapsedTimeColumn(),
-                        new RemainingTimeColumn(),
-                        new SpinnerColumn()
+                        new TaskDescriptionColumn(),  // Shows "42/100  00:15/01:30  filename.bin"
+                        new PercentageColumn()
                     )
                     .Start(ctx =>
                     {
-                        var task = ctx.AddTask("[green]Scanning...[/]", maxValue: 100);
+                        var task = ctx.AddTask("[dim]Scanning...[/]", maxValue: 100);
                         task.IsIndeterminate = true;
+                        var startTime = DateTime.Now;
 
                         stats = _program.StartProcessingDirectory(directoryPath, processingArgs, (current, total, currentFile) =>
                         {
                             if (total > 0)
                             {
                                 task.IsIndeterminate = false;
                                 task.MaxValue = total;
-                                task.Value = current;
+                                task.Value = Math.Min(current, total);  // Clamp to avoid overflow
 
-                                // Update description with count and current file (truncate if too long)
+                                // Calculate elapsed and remaining time
+                                var elapsed = DateTime.Now - startTime;
+                                var avgPerFile = current > 0 ? elapsed.TotalSeconds / current : 0;
+                                int remainingFiles = Math.Max(0, total - current);  // Ensure non-negative
+                                var remaining = TimeSpan.FromSeconds(avgPerFile * remainingFiles);
+
+                                // Format times as mm:ss
+                                string elapsedStr = $"{(int)elapsed.TotalMinutes:D2}:{elapsed.Seconds:D2}";
+                                string remainingStr = $"{(int)remaining.TotalMinutes:D2}:{remaining.Seconds:D2}";
+
+                                // Truncate filename if too long
                                 string fileName = Path.GetFileName(currentFile);
                                 if (fileName.Length > 25)
                                     fileName = fileName[..22] + "...";
-                                task.Description = $"[grey]{current}/{total}[/] [green]{fileName}[/]";
+
+                                task.Description = $"[blue]{current}/{total}[/]  [dim]{elapsedStr}/{remainingStr}[/]  [green]{fileName}[/]";
                             }
                         });
 
+                        // Final state
+                        var totalElapsed = DateTime.Now - startTime;
+                        string finalElapsed = $"{(int)totalElapsed.TotalMinutes:D2}:{totalElapsed.Seconds:D2}";
                         if (stats != null)
-                            task.Description = $"[grey]{stats.HandledFiles}/{stats.TotalFiles}[/] [green]Done[/]";
-                        else
-                            task.Description = "[green]Done[/]";
+                            task.Description = $"[blue]{stats.HandledFiles}/{stats.TotalFiles}[/]  [dim]{finalElapsed}[/]  [green]Done[/]";
                         task.Value = task.MaxValue;
                     });
             }

ReFrontier/Program.cs

@@ -397,8 +397,9 @@ public ProcessingStatistics ProcessMultipleLevels(
             // Use a concurrent queue to manage files/directories to process
             ConcurrentQueue<string> filesToProcess = new(filePathes);
 
-            // Track files already processed or queued to prevent duplicates
-            HashSet<string> processedFiles = new(filePathes, StringComparer.OrdinalIgnoreCase);
+            // Track files already processed, queued, or created as output to prevent duplicates
+            // This includes both input files and output files generated during processing
+            HashSet<string> processedOrOutputFiles = new(filePathes, StringComparer.OrdinalIgnoreCase);
             object processedFilesLock = new();
 
             // Consume (process) input files
@@ -417,6 +418,9 @@ public ProcessingStatistics ProcessMultipleLevels(
                 // to avoid race conditions where files are scanned while still being written
                 ConcurrentBag<string> outputDirectories = new();
 
+                // Collect output files to mark them as processed (prevents re-processing .jkr.bin files)
+                ConcurrentBag<string> outputFiles = new();
+
                 // Use Interlocked to safely disable stage processing after first file
                 int stageContainerFlag = inputArguments.stageContainer ? 1 : 0;
                 Parallel.ForEach(currentBatch, parallelOptions, inputFile =>
@@ -439,11 +443,20 @@ public ProcessingStatistics ProcessMultipleLevels(
                         // Report progress
                         progressCallback?.Invoke(stats.HandledFiles, stats.TotalFiles, inputFile);
 
-                        // Collect output directories for deferred processing
-                        // This prevents race conditions where files are scanned while being written
-                        if (inputArguments.recursive && result.OutputPath != null && _fileSystem.DirectoryExists(result.OutputPath))
+                        // Track output for deferred processing
+                        if (result.OutputPath != null)
                         {
-                            outputDirectories.Add(result.OutputPath);
+                            if (inputArguments.recursive && _fileSystem.DirectoryExists(result.OutputPath))
+                            {
+                                // Output is a directory - scan it later for new files
+                                outputDirectories.Add(result.OutputPath);
+                            }
+                            else if (_fileSystem.FileExists(result.OutputPath))
+                            {
+                                // Output is a file - mark it as processed to prevent re-queuing
+                                // This prevents .jkr.bin files from being picked up by *.bin pattern
+                                outputFiles.Add(result.OutputPath);
+                            }
                         }
                     }
                     catch (ReFrontierException ex)
@@ -455,13 +468,32 @@ public ProcessingStatistics ProcessMultipleLevels(
                         if (inputArguments.verbose)
                             _logger.WriteLine($"Skipping {inputFile}: {ex.Message}");
                     }
+                    catch (IOException ex)
+                    {
+                        stats.IncrementError();
+                        progressCallback?.Invoke(stats.HandledFiles, stats.TotalFiles, inputFile);
+
+                        // Log file access errors (e.g., file locked by another process)
+                        if (inputArguments.verbose)
+                            _logger.WriteLine($"Skipping {inputFile}: {ex.Message}");
+                    }
                 });
 
+                // Mark all output files as processed to prevent them from being re-queued
+                // This is critical for preventing .jkr.bin files from being picked up by *.bin pattern
+                lock (processedFilesLock)
+                {
+                    foreach (var outputFile in outputFiles)
+                    {
+                        processedOrOutputFiles.Add(outputFile);
+                    }
+                }
+
                 // After all files in batch are processed, scan output directories for new files
                 // This ensures all files are fully written before being added to the queue
                 foreach (var outputDir in outputDirectories)
                 {
-                    int newFileCount = AddNewFilesWithDedup(outputDir, filesToProcess, processedFiles, processedFilesLock);
+                    int newFileCount = AddNewFilesWithDedup(outputDir, filesToProcess, processedOrOutputFiles, processedFilesLock);
                     stats.AddGeneratedFiles(newFileCount);
                 }
             }

ReFrontier/Services/ProcessingStatistics.cs

@@ -76,11 +76,12 @@ public void IncrementError()
         }
 
         /// <summary>
-        /// Add to generated files count.
+        /// Add to generated files count and update total.
         /// </summary>
         public void AddGeneratedFiles(int count)
         {
             Interlocked.Add(ref _generatedFiles, count);
+            Interlocked.Add(ref _totalFiles, count);
         }
     }
 }