Add worker health status bar with color indicators

- Shows worker status below the panel: workers: ● ● ● ●
- Colors based on time since last activity:
  - Green: < 25% of timeout
  - Yellow: 25-50% of timeout
  - Orange: 50-75% of timeout
  - Red: > 75% of timeout
- Shows ⏳ during worker restart
- Shows ✓ when worker completes

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: rogeralsing

src/Asynkron.TestRunner/LiveDisplay.cs

@@ -27,6 +27,15 @@ public class LiveDisplay
     private string? _filter;
     private string? _assemblyName;
     private int _workerCount = 1;
+    private int _timeoutSeconds = 30;
+    private readonly Dictionary<int, WorkerState> _workerStates = new();
+
+    private class WorkerState
+    {
+        public DateTime LastActivity { get; set; } = DateTime.UtcNow;
+        public bool IsRestarting { get; set; }
+        public bool IsComplete { get; set; }
+    }
 
     public void SetTotal(int total)
     {
@@ -45,7 +54,47 @@ public void SetAssembly(string assemblyPath)
 
     public void SetWorkerCount(int count)
     {
-        lock (_lock) _workerCount = count;
+        lock (_lock)
+        {
+            _workerCount = count;
+            for (var i = 0; i < count; i++)
+                _workerStates[i] = new WorkerState();
+        }
+    }
+
+    public void SetTimeout(int seconds)
+    {
+        lock (_lock) _timeoutSeconds = seconds;
+    }
+
+    public void WorkerActivity(int workerIndex)
+    {
+        lock (_lock)
+        {
+            if (_workerStates.TryGetValue(workerIndex, out var state))
+            {
+                state.LastActivity = DateTime.UtcNow;
+                state.IsRestarting = false;
+            }
+        }
+    }
+
+    public void WorkerRestarting(int workerIndex)
+    {
+        lock (_lock)
+        {
+            if (_workerStates.TryGetValue(workerIndex, out var state))
+                state.IsRestarting = true;
+        }
+    }
+
+    public void WorkerComplete(int workerIndex)
+    {
+        lock (_lock)
+        {
+            if (_workerStates.TryGetValue(workerIndex, out var state))
+                state.IsComplete = true;
+        }
     }
 
     public void TestStarted(string displayName)
@@ -108,13 +157,6 @@ public void TestCrashed(string displayName)
         }
     }
 
-    public void WorkerRestarted(int remaining)
-    {
-        lock (_lock)
-        {
-            _running.Clear();
-        }
-    }
 
     public IRenderable Render()
     {
@@ -142,20 +184,30 @@ public IRenderable Render()
                 new Markup($"[dim]{elapsed:mm\\:ss}[/] [dim]({rate:F1}/s)[/]")
             );
 
-            var layout = new Rows(
+            var layoutItems = new List<IRenderable>
+            {
                 grid,
                 new Text(""),
                 CreateProgressBar(completed, _total),
                 new Text(""),
                 CreateRunningSection()
-            );
+            };
+
+            // Add worker status bar if multiple workers
+            if (_workerCount > 1)
+            {
+                layoutItems.Add(new Text(""));
+                layoutItems.Add(CreateWorkerStatusBar());
+            }
+
+            var layout = new Rows(layoutItems);
 
             // Build header: show filter if set, otherwise assembly name
             var headerText = !string.IsNullOrEmpty(_filter)
                 ? $"[blue]filter[/] [green]\"{_filter}\"[/]"
                 : _assemblyName ?? "Test Progress";
 
-            var workerText = _workerCount > 1 ? $" [dim]({_workerCount} workers)[/]" : "";
+            var workerText = _workerCount > 1 ? "" : ""; // Removed from header, shown in bar now
 
             var panel = new Panel(layout)
                 .Header($"{headerText}{workerText} [blue]({completed}/{_total})[/]")
@@ -225,6 +277,49 @@ private IRenderable CreateRunningSection()
         return new Rows(lines);
     }
 
+    private IRenderable CreateWorkerStatusBar()
+    {
+        var parts = new List<string> { "[dim]workers:[/]" };
+
+        for (var i = 0; i < _workerCount; i++)
+        {
+            if (!_workerStates.TryGetValue(i, out var state))
+            {
+                parts.Add("[dim]○[/]");
+                continue;
+            }
+
+            if (state.IsComplete)
+            {
+                parts.Add("[green]✓[/]");
+                continue;
+            }
+
+            if (state.IsRestarting)
+            {
+                parts.Add("[yellow]⏳[/]");
+                continue;
+            }
+
+            // Calculate health based on time since last activity
+            var elapsed = (DateTime.UtcNow - state.LastActivity).TotalSeconds;
+            var ratio = Math.Min(1.0, elapsed / _timeoutSeconds);
+
+            // Color gradient: green → yellow → orange → red
+            var color = ratio switch
+            {
+                < 0.25 => "green",
+                < 0.5 => "yellow",
+                < 0.75 => "orange3",
+                _ => "red"
+            };
+
+            parts.Add($"[{color}]●[/]");
+        }
+
+        return new Markup(string.Join(" ", parts));
+    }
+
     private static string Truncate(string text, int maxLength)
     {
         if (text.Length <= maxLength) return text;

src/Asynkron.TestRunner/TestRunner.cs

@@ -104,6 +104,7 @@ private async Task RunWithRecoveryLiveAsync(string assemblyPath, List<string> al
         display.SetFilter(_filter);
         display.SetAssembly(assemblyPath);
         display.SetWorkerCount(_workerCount);
+        display.SetTimeout(_testTimeoutSeconds);
 
         var failureDetails = new List<(string Name, string Message, string? Stack)>();
         var failureLock = new object();
@@ -205,6 +206,8 @@ private async Task RunWorkerBatchAsync(
                 await foreach (var msg in worker.RunAsync(assemblyPath, testsToRun, _testTimeoutSeconds, cts.Token)
                     .WithTimeout(TimeSpan.FromSeconds(_testTimeoutSeconds), cts))
                 {
+                    display.WorkerActivity(workerIndex);
+
                     switch (msg)
                     {
                         case TestStartedEvent started:
@@ -278,7 +281,7 @@ private async Task RunWorkerBatchAsync(
                     display.TestHanging(fqn);
                 }
                 worker.Kill();
-                display.WorkerRestarted(pending.Count);
+                display.WorkerRestarting(workerIndex);
             }
             catch (WorkerCrashedException)
             {
@@ -288,7 +291,7 @@ private async Task RunWorkerBatchAsync(
                     lock (results) results.Crashed.Add(fqn);
                     display.TestCrashed(fqn);
                 }
-                display.WorkerRestarted(pending.Count);
+                display.WorkerRestarting(workerIndex);
             }
             catch (Exception)
             {
@@ -303,6 +306,8 @@ private async Task RunWorkerBatchAsync(
             lock (results) results.Crashed.Add(fqn);
             display.TestCrashed(fqn);
         }
+
+        display.WorkerComplete(workerIndex);
     }
 
     private async Task RunWithRecoveryQuietAsync(string assemblyPath, List<string> allTests, TestResults results)