openadapt-ml 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

openadapt_ml/cloud/local.py

@@ -27,7 +27,6 @@ import http.server
 import json
 import os
 import shutil
-import signal
 import socketserver
 import subprocess
 import sys
@@ -109,7 +108,10 @@ def _is_mock_benchmark(benchmark_dir: Path) -> bool:
 
     # Check for test runs (but allow waa-mock evaluations with real API models)
     # Only filter out purely synthetic test data directories
-    if any(term in benchmark_dir.name.lower() for term in ["test_run", "test_cli", "quick_demo"]):
+    if any(
+        term in benchmark_dir.name.lower()
+        for term in ["test_run", "test_cli", "quick_demo"]
+    ):
         return True
 
     return False
@@ -193,6 +195,7 @@ def _regenerate_benchmark_viewer_if_available(output_dir: Path) -> bool:
     except Exception as e:
         print(f"  Could not regenerate benchmark viewer: {e}")
         import traceback
+
         traceback.print_exc()
         return False
 
@@ -201,6 +204,7 @@ def detect_device() -> str:
     """Detect available compute device."""
     try:
         import torch
+
         if torch.cuda.is_available():
             device_name = torch.cuda.get_device_name(0)
             return f"cuda ({device_name})"
@@ -251,10 +255,13 @@ def get_training_status() -> dict[str, Any]:
     # Find checkpoints
     checkpoints_dir = Path("checkpoints")
     if checkpoints_dir.exists():
-        status["checkpoints"] = sorted([
-            d.name for d in checkpoints_dir.iterdir()
-            if d.is_dir() and (d / "adapter_config.json").exists()
-        ])
+        status["checkpoints"] = sorted(
+            [
+                d.name
+                for d in checkpoints_dir.iterdir()
+                if d.is_dir() and (d / "adapter_config.json").exists()
+            ]
+        )
 
     return status
 
@@ -264,9 +271,9 @@ def cmd_status(args: argparse.Namespace) -> int:
     status = get_training_status()
     current_dir = get_current_output_dir()
 
-    print(f"\n{'='*50}")
+    print(f"\n{'=' * 50}")
     print("LOCAL TRAINING STATUS")
-    print(f"{'='*50}")
+    print(f"{'=' * 50}")
     print(f"Device: {status['device']}")
     print(f"Status: {'RUNNING' if status['running'] else 'IDLE'}")
     if status.get("job_id"):
@@ -274,7 +281,7 @@ def cmd_status(args: argparse.Namespace) -> int:
     print(f"Output: {current_dir}")
 
     if status.get("epoch"):
-        print(f"\nProgress:")
+        print("\nProgress:")
         print(f"  Epoch: {status['epoch']}")
         print(f"  Step: {status['step']}")
         if status.get("loss"):
@@ -287,7 +294,9 @@ def cmd_status(args: argparse.Namespace) -> int:
         for cp in status["checkpoints"][-5:]:  # Show last 5
             print(f"  - {cp}")
 
-    print(f"\nDashboard: {'✓' if status['has_dashboard'] else '✗'} {current_dir}/dashboard.html")
+    print(
+        f"\nDashboard: {'✓' if status['has_dashboard'] else '✗'} {current_dir}/dashboard.html"
+    )
     print(f"Viewer: {'✓' if status['has_viewer'] else '✗'} {current_dir}/viewer.html")
     print()
 
@@ -320,9 +329,9 @@ def cmd_train(args: argparse.Namespace) -> int:
         print(f"Error: Config not found: {config_path}")
         return 1
 
-    print(f"\n{'='*50}")
+    print(f"\n{'=' * 50}")
     print("STARTING LOCAL TRAINING")
-    print(f"{'='*50}")
+    print(f"{'=' * 50}")
     print(f"Capture: {capture_path}")
     print(f"Goal: {goal}")
     print(f"Config: {config}")
@@ -331,10 +340,15 @@ def cmd_train(args: argparse.Namespace) -> int:
 
     # Build command
     cmd = [
-        sys.executable, "-m", "openadapt_ml.scripts.train",
-        "--config", str(config_path),
-        "--capture", str(capture_path),
-        "--goal", goal,
+        sys.executable,
+        "-m",
+        "openadapt_ml.scripts.train",
+        "--config",
+        str(config_path),
+        "--capture",
+        str(capture_path),
+        "--goal",
+        goal,
     ]
 
     if args.open:
@@ -353,14 +367,16 @@ def cmd_check(args: argparse.Namespace) -> int:
     """Check training health and early stopping analysis."""
     status = get_training_status()
 
-    print(f"\n{'='*50}")
+    print(f"\n{'=' * 50}")
     print("TRAINING HEALTH CHECK")
-    print(f"{'='*50}")
+    print(f"{'=' * 50}")
 
     raw_losses = status.get("losses", [])
     if not raw_losses:
         print("No training data found.")
-        print("Run training first with: uv run python -m openadapt_ml.cloud.local train --capture <path>")
+        print(
+            "Run training first with: uv run python -m openadapt_ml.cloud.local train --capture <path>"
+        )
         return 1
 
     # Extract loss values (handle both dict and float formats)
@@ -381,7 +397,7 @@ def cmd_check(args: argparse.Namespace) -> int:
         min_loss = min(losses)
         max_loss = max(losses)
 
-        print(f"\nLoss progression:")
+        print("\nLoss progression:")
         print(f"  First: {first_loss:.4f}")
         print(f"  Last: {last_loss:.4f}")
         print(f"  Min: {min_loss:.4f}")
@@ -392,9 +408,11 @@ def cmd_check(args: argparse.Namespace) -> int:
         if len(losses) >= 10:
             recent = losses[-10:]
             recent_avg = sum(recent) / len(recent)
-            recent_std = (sum((x - recent_avg) ** 2 for x in recent) / len(recent)) ** 0.5
+            recent_std = (
+                sum((x - recent_avg) ** 2 for x in recent) / len(recent)
+            ) ** 0.5
 
-            print(f"\nRecent stability (last 10 steps):")
+            print("\nRecent stability (last 10 steps):")
             print(f"  Avg loss: {recent_avg:.4f}")
             print(f"  Std dev: {recent_std:.4f}")
 
@@ -413,14 +431,18 @@ def cmd_serve(args: argparse.Namespace) -> int:
     """Start local web server for dashboard.
 
     Automatically regenerates dashboard and viewer before serving to ensure
-    the latest code and data are reflected.
+    the latest code and data are reflected. Also ensures the 'current' symlink
+    points to the most recent training run.
     """
-    from openadapt_ml.training.trainer import regenerate_local_dashboard
+    from openadapt_ml.training.trainer import (
+        regenerate_local_dashboard,
+        update_current_symlink_to_latest,
+    )
 
     port = args.port
 
     # Determine what to serve: benchmark directory or training output
-    if hasattr(args, 'benchmark') and args.benchmark:
+    if hasattr(args, "benchmark") and args.benchmark:
         serve_dir = Path(args.benchmark).expanduser().resolve()
         if not serve_dir.exists():
             print(f"Error: Benchmark directory not found: {serve_dir}")
@@ -430,7 +452,10 @@ def cmd_serve(args: argparse.Namespace) -> int:
         if not args.no_regenerate:
             print("Regenerating benchmark viewer...")
             try:
-                from openadapt_ml.training.benchmark_viewer import generate_benchmark_viewer
+                from openadapt_ml.training.benchmark_viewer import (
+                    generate_benchmark_viewer,
+                )
+
                 generate_benchmark_viewer(serve_dir)
             except Exception as e:
                 print(f"Warning: Could not regenerate benchmark viewer: {e}")
@@ -439,6 +464,17 @@ def cmd_serve(args: argparse.Namespace) -> int:
     else:
         serve_dir = get_current_output_dir()
 
+        # If current symlink doesn't exist or is broken, update to latest run
+        if not serve_dir.exists() or not serve_dir.is_dir():
+            print("Updating 'current' symlink to latest training run...")
+            latest = update_current_symlink_to_latest()
+            if latest:
+                serve_dir = get_current_output_dir()
+                print(f"  Updated to: {latest.name}")
+            else:
+                print(f"Error: {serve_dir} not found. Run training first.")
+                return 1
+
         if not serve_dir.exists():
             print(f"Error: {serve_dir} not found. Run training first.")
             return 1
@@ -447,7 +483,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
         if not args.no_regenerate:
             print("Regenerating dashboard and viewer...")
             try:
-                regenerate_local_dashboard(str(serve_dir))
+                # Use keep_polling=True so JavaScript fetches live data from training_log.json
+                # This ensures the dashboard shows current data instead of stale embedded data
+                regenerate_local_dashboard(str(serve_dir), keep_polling=True)
                 # Also regenerate viewer if comparison data exists
                 _regenerate_viewer_if_possible(serve_dir)
             except Exception as e:
@@ -456,10 +494,21 @@ def cmd_serve(args: argparse.Namespace) -> int:
             # Also regenerate benchmark viewer from latest benchmark results
             _regenerate_benchmark_viewer_if_available(serve_dir)
 
+            # Generate Azure ops dashboard
+            try:
+                from openadapt_ml.training.azure_ops_viewer import (
+                    generate_azure_ops_dashboard,
+                )
+
+                generate_azure_ops_dashboard(serve_dir / "azure_ops.html")
+                print("  Generated Azure ops dashboard")
+            except Exception as e:
+                print(f"  Warning: Could not generate Azure ops dashboard: {e}")
+
         start_page = "dashboard.html"
 
     # Override start page if specified
-    if hasattr(args, 'start_page') and args.start_page:
+    if hasattr(args, "start_page") and args.start_page:
         start_page = args.start_page
 
     # Serve from the specified directory
@@ -476,33 +525,41 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 super().log_message(format, *log_args)
 
         def do_POST(self):
-            if self.path == '/api/stop':
+            if self.path == "/api/stop":
                 # Create stop signal file
                 stop_file = serve_dir / "STOP_TRAINING"
                 stop_file.touch()
                 self.send_response(200)
-                self.send_header('Content-Type', 'application/json')
-                self.send_header('Access-Control-Allow-Origin', '*')
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.end_headers()
                 self.wfile.write(b'{"status": "stop_signal_created"}')
                 print(f"\n⏹ Stop signal created: {stop_file}")
-            elif self.path == '/api/run-benchmark':
+            elif self.path == "/api/run-benchmark":
                 # Parse request body for provider
-                content_length = int(self.headers.get('Content-Length', 0))
-                body = self.rfile.read(content_length).decode('utf-8') if content_length else '{}'
+                content_length = int(self.headers.get("Content-Length", 0))
+                body = (
+                    self.rfile.read(content_length).decode("utf-8")
+                    if content_length
+                    else "{}"
+                )
                 try:
                     params = json.loads(body)
                 except json.JSONDecodeError:
                     params = {}
 
-                provider = params.get('provider', 'anthropic')
-                tasks = params.get('tasks', 5)
+                provider = params.get("provider", "anthropic")
+                tasks = params.get("tasks", 5)
 
                 self.send_response(200)
-                self.send_header('Content-Type', 'application/json')
-                self.send_header('Access-Control-Allow-Origin', '*')
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.end_headers()
-                self.wfile.write(json.dumps({"status": "started", "provider": provider, "tasks": tasks}).encode())
+                self.wfile.write(
+                    json.dumps(
+                        {"status": "started", "provider": provider, "tasks": tasks}
+                    ).encode()
+                )
 
                 # Run benchmark in background thread with progress logging
                 def run_benchmark():
@@ -516,25 +573,45 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     # Create progress log file (in cwd which is serve_dir)
                     progress_file = Path("benchmark_progress.json")
 
-                    print(f"\n🚀 Starting {provider} benchmark evaluation ({tasks} tasks)...")
+                    print(
+                        f"\n🚀 Starting {provider} benchmark evaluation ({tasks} tasks)..."
+                    )
 
                     # Write initial progress
-                    progress_file.write_text(json.dumps({
-                        "status": "running",
-                        "provider": provider,
-                        "tasks_total": tasks,
-                        "tasks_complete": 0,
-                        "message": f"Starting {provider} evaluation..."
-                    }))
+                    progress_file.write_text(
+                        json.dumps(
+                            {
+                                "status": "running",
+                                "provider": provider,
+                                "tasks_total": tasks,
+                                "tasks_complete": 0,
+                                "message": f"Starting {provider} evaluation...",
+                            }
+                        )
+                    )
 
                     # Copy environment with loaded vars
                     env = os.environ.copy()
 
                     result = subprocess.run(
-                        ["uv", "run", "python", "-m", "openadapt_ml.benchmarks.cli", "run-api",
-                         "--provider", provider, "--tasks", str(tasks),
-                         "--model-id", f"{provider}-api"],
-                        capture_output=True, text=True, cwd=str(project_root), env=env
+                        [
+                            "uv",
+                            "run",
+                            "python",
+                            "-m",
+                            "openadapt_ml.benchmarks.cli",
+                            "run-api",
+                            "--provider",
+                            provider,
+                            "--tasks",
+                            str(tasks),
+                            "--model-id",
+                            f"{provider}-api",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        cwd=str(project_root),
+                        env=env,
                     )
 
                     print(f"\n📋 Benchmark output:\n{result.stdout}")
@@ -542,77 +619,95 @@ def cmd_serve(args: argparse.Namespace) -> int:
                         print(f"Stderr: {result.stderr}")
 
                     if result.returncode == 0:
-                        print(f"✅ Benchmark complete. Regenerating viewer...")
-                        progress_file.write_text(json.dumps({
-                            "status": "complete",
-                            "provider": provider,
-                            "message": "Evaluation complete! Refreshing results..."
-                        }))
+                        print("✅ Benchmark complete. Regenerating viewer...")
+                        progress_file.write_text(
+                            json.dumps(
+                                {
+                                    "status": "complete",
+                                    "provider": provider,
+                                    "message": "Evaluation complete! Refreshing results...",
+                                }
+                            )
+                        )
                         # Regenerate benchmark viewer
                         _regenerate_benchmark_viewer_if_available(serve_dir)
                     else:
                         print(f"❌ Benchmark failed: {result.stderr}")
-                        progress_file.write_text(json.dumps({
-                            "status": "error",
-                            "provider": provider,
-                            "message": f"Evaluation failed: {result.stderr[:200]}"
-                        }))
+                        progress_file.write_text(
+                            json.dumps(
+                                {
+                                    "status": "error",
+                                    "provider": provider,
+                                    "message": f"Evaluation failed: {result.stderr[:200]}",
+                                }
+                            )
+                        )
 
                 threading.Thread(target=run_benchmark, daemon=True).start()
-            elif self.path == '/api/vms/register':
+            elif self.path == "/api/vms/register":
                 # Register a new VM
-                content_length = int(self.headers.get('Content-Length', 0))
-                body = self.rfile.read(content_length).decode('utf-8') if content_length else '{}'
+                content_length = int(self.headers.get("Content-Length", 0))
+                body = (
+                    self.rfile.read(content_length).decode("utf-8")
+                    if content_length
+                    else "{}"
+                )
                 try:
                     vm_data = json.loads(body)
                     result = self._register_vm(vm_data)
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(result).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
-            elif self.path == '/api/benchmark/start':
+            elif self.path == "/api/benchmark/start":
                 # Start a benchmark run with configurable parameters
-                content_length = int(self.headers.get('Content-Length', 0))
-                body = self.rfile.read(content_length).decode('utf-8') if content_length else '{}'
+                content_length = int(self.headers.get("Content-Length", 0))
+                body = (
+                    self.rfile.read(content_length).decode("utf-8")
+                    if content_length
+                    else "{}"
+                )
                 try:
                     params = json.loads(body)
                     result = self._start_benchmark_run(params)
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(result).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
             else:
                 self.send_error(404, "Not found")
 
         def do_GET(self):
-            if self.path.startswith('/api/benchmark-progress'):
+            if self.path.startswith("/api/benchmark-progress"):
                 # Return benchmark progress
-                progress_file = Path("benchmark_progress.json")  # Relative to serve_dir (cwd)
+                progress_file = Path(
+                    "benchmark_progress.json"
+                )  # Relative to serve_dir (cwd)
                 if progress_file.exists():
                     progress = progress_file.read_text()
                 else:
                     progress = json.dumps({"status": "idle"})
 
                 self.send_response(200)
-                self.send_header('Content-Type', 'application/json')
-                self.send_header('Access-Control-Allow-Origin', '*')
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.end_headers()
                 self.wfile.write(progress.encode())
-            elif self.path.startswith('/api/benchmark-live'):
+            elif self.path.startswith("/api/benchmark-live"):
                 # Return live evaluation state
                 live_file = Path("benchmark_live.json")  # Relative to serve_dir (cwd)
                 if live_file.exists():
@@ -621,32 +716,33 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     live_state = json.dumps({"status": "idle"})
 
                 self.send_response(200)
-                self.send_header('Content-Type', 'application/json')
-                self.send_header('Access-Control-Allow-Origin', '*')
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Access-Control-Allow-Origin", "*")
                 self.end_headers()
                 self.wfile.write(live_state.encode())
-            elif self.path.startswith('/api/tasks'):
+            elif self.path.startswith("/api/tasks"):
                 # Return background task status (VM, Docker, benchmarks)
                 try:
                     tasks = self._fetch_background_tasks()
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(tasks).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
-            elif self.path.startswith('/api/azure-jobs'):
+            elif self.path.startswith("/api/azure-jobs"):
                 # Return LIVE Azure job status from Azure ML
                 # Supports ?force=true parameter for manual refresh (always fetches live)
                 try:
                     from urllib.parse import urlparse, parse_qs
+
                     query = parse_qs(urlparse(self.path).query)
-                    force_refresh = query.get('force', ['false'])[0].lower() == 'true'
+                    force_refresh = query.get("force", ["false"])[0].lower() == "true"
 
                     # Always fetch live data (force just indicates manual refresh for logging)
                     if force_refresh:
@@ -654,22 +750,23 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                     jobs = self._fetch_live_azure_jobs()
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(jobs).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
-            elif self.path.startswith('/api/benchmark-sse'):
+            elif self.path.startswith("/api/benchmark-sse"):
                 # Server-Sent Events endpoint for real-time benchmark updates
                 try:
                     from urllib.parse import urlparse, parse_qs
+
                     query = parse_qs(urlparse(self.path).query)
-                    interval = int(query.get('interval', [5])[0])
+                    interval = int(query.get("interval", [5])[0])
 
                     # Validate interval (min 1s, max 60s)
                     interval = max(1, min(60, interval))
@@ -677,57 +774,60 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     self._stream_benchmark_updates(interval)
                 except Exception as e:
                     self.send_error(500, f"SSE error: {e}")
-            elif self.path.startswith('/api/vms'):
+            elif self.path.startswith("/api/vms"):
                 # Return VM registry with live status
                 try:
                     vms = self._fetch_vm_registry()
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(vms).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
-            elif self.path.startswith('/api/azure-job-logs'):
+            elif self.path.startswith("/api/azure-job-logs"):
                 # Return live logs for running Azure job
                 try:
                     # Parse job_id from query string
                     from urllib.parse import urlparse, parse_qs
+
                     query = parse_qs(urlparse(self.path).query)
-                    job_id = query.get('job_id', [None])[0]
+                    job_id = query.get("job_id", [None])[0]
 
                     logs = self._fetch_azure_job_logs(job_id)
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(logs).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
-            elif self.path.startswith('/api/probe-vm'):
+            elif self.path.startswith("/api/probe-vm"):
                 # Probe the VM to check if WAA server is responding
                 try:
                     result = self._probe_vm()
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(result).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
-                    self.wfile.write(json.dumps({"error": str(e), "responding": False}).encode())
-            elif self.path.startswith('/api/tunnels'):
+                    self.wfile.write(
+                        json.dumps({"error": str(e), "responding": False}).encode()
+                    )
+            elif self.path.startswith("/api/tunnels"):
                 # Return SSH tunnel status
                 try:
                     tunnel_mgr = get_tunnel_manager()
@@ -743,44 +843,293 @@ def cmd_serve(args: argparse.Namespace) -> int:
                         for name, s in status.items()
                     }
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(result).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
-            elif self.path.startswith('/api/current-run'):
+            elif self.path.startswith("/api/current-run"):
                 # Return currently running benchmark info
                 try:
                     result = self._get_current_run()
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(result).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
-                    self.wfile.write(json.dumps({"error": str(e), "running": False}).encode())
-            elif self.path.startswith('/api/background-tasks'):
+                    self.wfile.write(
+                        json.dumps({"error": str(e), "running": False}).encode()
+                    )
+            elif self.path.startswith("/api/background-tasks"):
                 # Alias for /api/tasks - background task status
                 try:
                     tasks = self._fetch_background_tasks()
                     self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps(tasks).encode())
                 except Exception as e:
                     self.send_response(500)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/benchmark/status"):
+                # Return current benchmark job status with ETA
+                try:
+                    status = self._get_benchmark_status()
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(status).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(
+                        json.dumps({"error": str(e), "status": "error"}).encode()
+                    )
+            elif self.path.startswith("/api/benchmark/costs"):
+                # Return cost breakdown (Azure VM, API calls, GPU)
+                try:
+                    costs = self._get_benchmark_costs()
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(costs).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/benchmark/metrics"):
+                # Return performance metrics (success rate, domain breakdown)
+                try:
+                    metrics = self._get_benchmark_metrics()
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(metrics).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/benchmark/workers"):
+                # Return worker status and utilization
+                try:
+                    workers = self._get_benchmark_workers()
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(workers).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/benchmark/runs"):
+                # Return list of all benchmark runs
+                try:
+                    runs = self._get_benchmark_runs()
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(runs).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/benchmark/tasks/"):
+                # Return task execution details
+                # URL format: /api/benchmark/tasks/{run_name}/{task_id}
+                try:
+                    parts = self.path.split("/")
+                    if len(parts) >= 6:
+                        run_name = parts[4]
+                        task_id = parts[5]
+                        execution = self._get_task_execution(run_name, task_id)
+                        self.send_response(200)
+                        self.send_header("Content-Type", "application/json")
+                        self.send_header("Access-Control-Allow-Origin", "*")
+                        self.end_headers()
+                        self.wfile.write(json.dumps(execution).encode())
+                    else:
+                        self.send_error(400, "Invalid path format")
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/benchmark/screenshots/"):
+                # Serve screenshot files
+                # URL format: /api/benchmark/screenshots/{run_name}/{task_id}/screenshots/{filename}
+                try:
+                    # Remove /api/benchmark/screenshots/ prefix
+                    path_parts = self.path.replace(
+                        "/api/benchmark/screenshots/", ""
+                    ).split("/")
+                    if len(path_parts) >= 4:
+                        run_name = path_parts[0]
+                        task_id = path_parts[1]
+                        # path_parts[2] should be 'screenshots'
+                        filename = path_parts[3]
+
+                        results_dir = Path("benchmark_results")
+                        screenshot_path = (
+                            results_dir
+                            / run_name
+                            / "tasks"
+                            / task_id
+                            / "screenshots"
+                            / filename
+                        )
+
+                        if screenshot_path.exists():
+                            self.send_response(200)
+                            self.send_header("Content-Type", "image/png")
+                            self.send_header("Access-Control-Allow-Origin", "*")
+                            self.end_headers()
+                            with open(screenshot_path, "rb") as f:
+                                self.wfile.write(f.read())
+                        else:
+                            self.send_error(
+                                404, f"Screenshot not found: {screenshot_path}"
+                            )
+                    else:
+                        self.send_error(400, "Invalid screenshot path format")
+                except Exception as e:
+                    self.send_error(500, f"Error serving screenshot: {e}")
+            elif self.path.startswith("/api/azure-ops-sse"):
+                # Server-Sent Events endpoint for Azure operations status
+                try:
+                    self._stream_azure_ops_updates()
+                except Exception as e:
+                    self.send_error(500, f"SSE error: {e}")
+            elif self.path.startswith("/api/azure-ops-status"):
+                # Return Azure operations status from JSON file
+                # Session tracker provides elapsed_seconds and cost_usd for
+                # persistence across page refreshes
+                try:
+                    from openadapt_ml.benchmarks.azure_ops_tracker import read_status
+                    from openadapt_ml.benchmarks.session_tracker import (
+                        get_session,
+                        update_session_vm_state,
+                    )
+
+                    # Get operation status (current task)
+                    status = read_status()
+
+                    # Get session data (persistent across refreshes)
+                    session = get_session()
+
+                    # Update session based on VM state if we have VM info
+                    # IMPORTANT: Only pass vm_ip if it's truthy to avoid
+                    # overwriting session's stable vm_ip with None
+                    if status.get("vm_state") and status.get("vm_state") != "unknown":
+                        status_vm_ip = status.get("vm_ip")
+                        # Build update kwargs - only include vm_ip if present
+                        update_kwargs = {
+                            "vm_state": status["vm_state"],
+                            "vm_size": status.get("vm_size"),
+                        }
+                        if status_vm_ip:  # Only include if truthy
+                            update_kwargs["vm_ip"] = status_vm_ip
+                        session = update_session_vm_state(**update_kwargs)
+
+                    # Use session's vm_ip as authoritative source
+                    # This prevents IP flickering when status file has stale/None values
+                    if session.get("vm_ip"):
+                        status["vm_ip"] = session["vm_ip"]
+
+                    # Use session's elapsed_seconds and cost_usd for persistence
+                    # These survive page refreshes and track total VM runtime
+                    if (
+                        session.get("is_active")
+                        or session.get("accumulated_seconds", 0) > 0
+                    ):
+                        status["elapsed_seconds"] = session.get("elapsed_seconds", 0.0)
+                        status["cost_usd"] = session.get("cost_usd", 0.0)
+                        status["started_at"] = session.get("started_at")
+                        # Include session metadata for debugging
+                        status["session_id"] = session.get("session_id")
+                        status["session_is_active"] = session.get("is_active", False)
+                        # Include accumulated time from previous sessions for hybrid display
+                        status["accumulated_seconds"] = session.get(
+                            "accumulated_seconds", 0.0
+                        )
+                        # Calculate current session time (total - accumulated)
+                        current_session_seconds = max(
+                            0, status["elapsed_seconds"] - status["accumulated_seconds"]
+                        )
+                        status["current_session_seconds"] = current_session_seconds
+                        status["current_session_cost_usd"] = (
+                            current_session_seconds / 3600
+                        ) * session.get("hourly_rate_usd", 0.422)
+
+                    try:
+                        tunnel_mgr = get_tunnel_manager()
+                        tunnel_status = tunnel_mgr.get_tunnel_status()
+                        status["tunnels"] = {
+                            name: {
+                                "active": s.active,
+                                "local_port": s.local_port,
+                                "remote_endpoint": s.remote_endpoint,
+                                "pid": s.pid,
+                                "error": s.error,
+                            }
+                            for name, s in tunnel_status.items()
+                        }
+                    except Exception as e:
+                        status["tunnels"] = {"error": str(e)}
+
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(status).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+            elif self.path.startswith("/api/vm-diagnostics"):
+                # Return VM diagnostics: disk usage, Docker stats, memory usage
+                try:
+                    diagnostics = self._get_vm_diagnostics()
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(diagnostics).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.send_header("Content-Type", "application/json")
+                    self.send_header("Access-Control-Allow-Origin", "*")
                     self.end_headers()
                     self.wfile.write(json.dumps({"error": str(e)}).encode())
             else:
@@ -790,13 +1139,25 @@ def cmd_serve(args: argparse.Namespace) -> int:
         def _fetch_live_azure_jobs(self):
             """Fetch live job status from Azure ML."""
             import subprocess
+
             result = subprocess.run(
-                ["az", "ml", "job", "list",
-                 "--resource-group", "openadapt-agents",
-                 "--workspace-name", "openadapt-ml",
-                 "--query", "[].{name:name,display_name:display_name,status:status,creation_context:creation_context.created_at}",
-                 "-o", "json"],
-                capture_output=True, text=True, timeout=30
+                [
+                    "az",
+                    "ml",
+                    "job",
+                    "list",
+                    "--resource-group",
+                    "openadapt-agents",
+                    "--workspace-name",
+                    "openadapt-ml",
+                    "--query",
+                    "[].{name:name,display_name:display_name,status:status,creation_context:creation_context.created_at}",
+                    "-o",
+                    "json",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=30,
             )
             if result.returncode != 0:
                 raise Exception(f"Azure CLI error: {result.stderr}")
@@ -808,14 +1169,16 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
             formatted = []
             for job in jobs[:10]:  # Limit to 10 most recent
-                formatted.append({
-                    "job_id": job.get("name", "unknown"),
-                    "display_name": job.get("display_name", ""),
-                    "status": job.get("status", "unknown").lower(),
-                    "started_at": job.get("creation_context", ""),
-                    "azure_dashboard_url": f"https://ml.azure.com/experiments/id/{experiment_id}/runs/{job.get('name', '')}?wsid={wsid}",
-                    "is_live": True  # Flag to indicate this is live data
-                })
+                formatted.append(
+                    {
+                        "job_id": job.get("name", "unknown"),
+                        "display_name": job.get("display_name", ""),
+                        "status": job.get("status", "unknown").lower(),
+                        "started_at": job.get("creation_context", ""),
+                        "azure_dashboard_url": f"https://ml.azure.com/experiments/id/{experiment_id}/runs/{job.get('name', '')}?wsid={wsid}",
+                        "is_live": True,  # Flag to indicate this is live data
+                    }
+                )
             return formatted
 
         def _fetch_azure_job_logs(self, job_id: str | None):
@@ -825,34 +1188,63 @@ def cmd_serve(args: argparse.Namespace) -> int:
             if not job_id:
                 # Get the most recent running job
                 jobs = self._fetch_live_azure_jobs()
-                running = [j for j in jobs if j['status'] == 'running']
+                running = [j for j in jobs if j["status"] == "running"]
                 if running:
-                    job_id = running[0]['job_id']
+                    job_id = running[0]["job_id"]
                 else:
-                    return {"logs": "No running jobs found", "job_id": None, "status": "idle"}
+                    return {
+                        "logs": "No running jobs found",
+                        "job_id": None,
+                        "status": "idle",
+                    }
 
             # Try to stream logs for running job using az ml job stream
             try:
                 result = subprocess.run(
-                    ["az", "ml", "job", "stream",
-                     "--name", job_id,
-                     "--resource-group", "openadapt-agents",
-                     "--workspace-name", "openadapt-ml"],
-                    capture_output=True, text=True, timeout=3  # Short timeout
+                    [
+                        "az",
+                        "ml",
+                        "job",
+                        "stream",
+                        "--name",
+                        job_id,
+                        "--resource-group",
+                        "openadapt-agents",
+                        "--workspace-name",
+                        "openadapt-ml",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=3,  # Short timeout
                 )
                 if result.returncode == 0 and result.stdout.strip():
-                    return {"logs": result.stdout[-5000:], "job_id": job_id, "status": "streaming"}
+                    return {
+                        "logs": result.stdout[-5000:],
+                        "job_id": job_id,
+                        "status": "streaming",
+                    }
             except subprocess.TimeoutExpired:
                 pass  # Fall through to job show
 
             # Get job details instead
             result = subprocess.run(
-                ["az", "ml", "job", "show",
-                 "--name", job_id,
-                 "--resource-group", "openadapt-agents",
-                 "--workspace-name", "openadapt-ml",
-                 "-o", "json"],
-                capture_output=True, text=True, timeout=10
+                [
+                    "az",
+                    "ml",
+                    "job",
+                    "show",
+                    "--name",
+                    job_id,
+                    "--resource-group",
+                    "openadapt-agents",
+                    "--workspace-name",
+                    "openadapt-ml",
+                    "-o",
+                    "json",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=10,
             )
 
             if result.returncode == 0:
@@ -860,20 +1252,25 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 return {
                     "logs": f"Job {job_id} is {job_info.get('status', 'unknown')}\\n\\nCommand: {job_info.get('command', 'N/A')}",
                     "job_id": job_id,
-                    "status": job_info.get('status', 'unknown').lower(),
-                    "command": job_info.get('command', '')
+                    "status": job_info.get("status", "unknown").lower(),
+                    "command": job_info.get("command", ""),
                 }
 
-            return {"logs": f"Could not fetch logs: {result.stderr}", "job_id": job_id, "status": "error"}
+            return {
+                "logs": f"Could not fetch logs: {result.stderr}",
+                "job_id": job_id,
+                "status": "error",
+            }
 
-        def _get_vm_detailed_metadata(self, vm_ip: str, container_name: str, logs: str, phase: str) -> dict:
+        def _get_vm_detailed_metadata(
+            self, vm_ip: str, container_name: str, logs: str, phase: str
+        ) -> dict:
             """Get detailed VM metadata for the VM Details panel.
 
             Returns:
                 dict with disk_usage_gb, memory_usage_mb, setup_script_phase, probe_response, qmp_connected, dependencies
             """
             import subprocess
-            import re
 
             metadata = {
                 "disk_usage_gb": None,
@@ -881,17 +1278,26 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 "setup_script_phase": None,
                 "probe_response": None,
                 "qmp_connected": False,
-                "dependencies": []
+                "dependencies": [],
             }
 
             # 1. Get disk usage from docker stats
             try:
                 disk_result = subprocess.run(
-                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                     "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                     f"azureuser@{vm_ip}",
-                     f"docker exec {container_name} df -h /storage 2>/dev/null | tail -1"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "ConnectTimeout=5",
+                        "-i",
+                        str(Path.home() / ".ssh" / "id_rsa"),
+                        f"azureuser@{vm_ip}",
+                        f"docker exec {container_name} df -h /storage 2>/dev/null | tail -1",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
                 if disk_result.returncode == 0 and disk_result.stdout.strip():
                     # Parse: "Filesystem      Size  Used Avail Use% Mounted on"
@@ -900,27 +1306,40 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     if len(parts) >= 3:
                         used_str = parts[2]  # e.g., "9.2G"
                         total_str = parts[1]  # e.g., "30G"
+
                         # Convert to GB (handle M/G suffixes)
                         def to_gb(s):
-                            if s.endswith('G'):
+                            if s.endswith("G"):
                                 return float(s[:-1])
-                            elif s.endswith('M'):
+                            elif s.endswith("M"):
                                 return float(s[:-1]) / 1024
-                            elif s.endswith('K'):
+                            elif s.endswith("K"):
                                 return float(s[:-1]) / (1024 * 1024)
                             return 0
-                        metadata["disk_usage_gb"] = f"{to_gb(used_str):.1f} GB / {to_gb(total_str):.0f} GB used"
+
+                        metadata["disk_usage_gb"] = (
+                            f"{to_gb(used_str):.1f} GB / {to_gb(total_str):.0f} GB used"
+                        )
             except Exception:
                 pass
 
             # 2. Get memory usage from docker stats
             try:
                 mem_result = subprocess.run(
-                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                     "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                     f"azureuser@{vm_ip}",
-                     f"docker stats {container_name} --no-stream --format '{{{{.MemUsage}}}}'"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "ConnectTimeout=5",
+                        "-i",
+                        str(Path.home() / ".ssh" / "id_rsa"),
+                        f"azureuser@{vm_ip}",
+                        f"docker stats {container_name} --no-stream --format '{{{{.MemUsage}}}}'",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
                 if mem_result.returncode == 0 and mem_result.stdout.strip():
                     # Example: "1.5GiB / 4GiB"
@@ -929,16 +1348,27 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 pass
 
             # 3. Parse setup script phase from logs
-            metadata["setup_script_phase"] = self._parse_setup_phase_from_logs(logs, phase)
+            metadata["setup_script_phase"] = self._parse_setup_phase_from_logs(
+                logs, phase
+            )
 
             # 4. Check /probe endpoint
             try:
                 probe_result = subprocess.run(
-                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                     "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                     f"azureuser@{vm_ip}",
-                     "curl -s --connect-timeout 2 http://20.20.20.21:5000/probe 2>/dev/null"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "ConnectTimeout=5",
+                        "-i",
+                        str(Path.home() / ".ssh" / "id_rsa"),
+                        f"azureuser@{vm_ip}",
+                        "curl -s --connect-timeout 2 http://20.20.20.21:5000/probe 2>/dev/null",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
                 if probe_result.returncode == 0 and probe_result.stdout.strip():
                     metadata["probe_response"] = probe_result.stdout.strip()
@@ -950,11 +1380,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
             # 5. Check QMP connection (port 7200)
             try:
                 qmp_result = subprocess.run(
-                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                     "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                     f"azureuser@{vm_ip}",
-                     "nc -z -w2 localhost 7200 2>&1"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "ConnectTimeout=5",
+                        "-i",
+                        str(Path.home() / ".ssh" / "id_rsa"),
+                        f"azureuser@{vm_ip}",
+                        "nc -z -w2 localhost 7200 2>&1",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
                 metadata["qmp_connected"] = qmp_result.returncode == 0
             except Exception:
@@ -987,7 +1426,12 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     return "Windows installation in progress"
             elif current_phase == "booting":
                 return "Booting Windows"
-            elif current_phase in ["downloading", "extracting", "configuring", "building"]:
+            elif current_phase in [
+                "downloading",
+                "extracting",
+                "configuring",
+                "building",
+            ]:
                 return "Preparing Windows VM"
             else:
                 return "Initializing..."
@@ -1017,17 +1461,23 @@ def cmd_serve(args: argparse.Namespace) -> int:
             logs_lower = logs.lower()
 
             # Check for installation patterns
-            if "python" in logs_lower and ("installing python" in logs_lower or "python.exe" in logs_lower):
+            if "python" in logs_lower and (
+                "installing python" in logs_lower or "python.exe" in logs_lower
+            ):
                 dependencies[0]["status"] = "installing"
             elif "python" in logs_lower and "installed" in logs_lower:
                 dependencies[0]["status"] = "complete"
 
-            if "chrome" in logs_lower and ("downloading" in logs_lower or "installing" in logs_lower):
+            if "chrome" in logs_lower and (
+                "downloading" in logs_lower or "installing" in logs_lower
+            ):
                 dependencies[1]["status"] = "installing"
             elif "chrome" in logs_lower and "installed" in logs_lower:
                 dependencies[1]["status"] = "complete"
 
-            if "libreoffice" in logs_lower and ("downloading" in logs_lower or "installing" in logs_lower):
+            if "libreoffice" in logs_lower and (
+                "downloading" in logs_lower or "installing" in logs_lower
+            ):
                 dependencies[2]["status"] = "installing"
             elif "libreoffice" in logs_lower and "installed" in logs_lower:
                 dependencies[2]["status"] = "complete"
@@ -1046,11 +1496,222 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
             return dependencies
 
+        def _get_vm_diagnostics(self) -> dict:
+            """Get VM diagnostics: disk usage, Docker stats, memory usage.
+
+            Returns a dictionary with:
+            - vm_online: bool - whether VM is reachable
+            - disk_usage: list of disk partitions with usage stats
+            - docker_stats: list of container stats (CPU, memory)
+            - memory_usage: VM host memory stats
+            - docker_system: Docker system disk usage
+            - error: str if any error occurred
+            """
+            import subprocess
+
+            from openadapt_ml.benchmarks.session_tracker import get_session
+
+            diagnostics = {
+                "vm_online": False,
+                "disk_usage": [],
+                "docker_stats": [],
+                "memory_usage": {},
+                "docker_system": {},
+                "docker_images": [],
+                "error": None,
+            }
+
+            # Get VM IP from session
+            session = get_session()
+            vm_ip = session.get("vm_ip")
+
+            if not vm_ip:
+                diagnostics["error"] = (
+                    "VM IP not found in session. VM may not be running."
+                )
+                return diagnostics
+
+            # SSH options for Azure VM
+            ssh_opts = [
+                "-o",
+                "StrictHostKeyChecking=no",
+                "-o",
+                "UserKnownHostsFile=/dev/null",
+                "-o",
+                "ConnectTimeout=10",
+                "-o",
+                "ServerAliveInterval=30",
+            ]
+
+            # Test VM connectivity
+            try:
+                test_result = subprocess.run(
+                    ["ssh", *ssh_opts, f"azureuser@{vm_ip}", "echo 'online'"],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if test_result.returncode != 0:
+                    diagnostics["error"] = f"Cannot connect to VM at {vm_ip}"
+                    return diagnostics
+                diagnostics["vm_online"] = True
+            except subprocess.TimeoutExpired:
+                diagnostics["error"] = f"Connection to VM at {vm_ip} timed out"
+                return diagnostics
+            except Exception as e:
+                diagnostics["error"] = f"SSH error: {str(e)}"
+                return diagnostics
+
+            # 1. Disk usage (df -h)
+            try:
+                df_result = subprocess.run(
+                    [
+                        "ssh",
+                        *ssh_opts,
+                        f"azureuser@{vm_ip}",
+                        "df -h / /mnt 2>/dev/null | tail -n +2",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if df_result.returncode == 0 and df_result.stdout.strip():
+                    for line in df_result.stdout.strip().split("\n"):
+                        parts = line.split()
+                        if len(parts) >= 6:
+                            diagnostics["disk_usage"].append(
+                                {
+                                    "filesystem": parts[0],
+                                    "size": parts[1],
+                                    "used": parts[2],
+                                    "available": parts[3],
+                                    "use_percent": parts[4],
+                                    "mount_point": parts[5],
+                                }
+                            )
+            except Exception as e:
+                diagnostics["disk_usage"] = [{"error": str(e)}]
+
+            # 2. Docker container stats
+            try:
+                stats_result = subprocess.run(
+                    [
+                        "ssh",
+                        *ssh_opts,
+                        f"azureuser@{vm_ip}",
+                        "docker stats --no-stream --format '{{.Name}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}|{{.NetIO}}|{{.BlockIO}}' 2>/dev/null || echo ''",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                )
+                if stats_result.returncode == 0 and stats_result.stdout.strip():
+                    for line in stats_result.stdout.strip().split("\n"):
+                        if "|" in line:
+                            parts = line.split("|")
+                            if len(parts) >= 6:
+                                diagnostics["docker_stats"].append(
+                                    {
+                                        "container": parts[0],
+                                        "cpu_percent": parts[1],
+                                        "memory_usage": parts[2],
+                                        "memory_percent": parts[3],
+                                        "net_io": parts[4],
+                                        "block_io": parts[5],
+                                    }
+                                )
+            except Exception as e:
+                diagnostics["docker_stats"] = [{"error": str(e)}]
+
+            # 3. VM host memory usage (free -h)
+            try:
+                mem_result = subprocess.run(
+                    [
+                        "ssh",
+                        *ssh_opts,
+                        f"azureuser@{vm_ip}",
+                        "free -h | head -2 | tail -1",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if mem_result.returncode == 0 and mem_result.stdout.strip():
+                    parts = mem_result.stdout.strip().split()
+                    if len(parts) >= 7:
+                        diagnostics["memory_usage"] = {
+                            "total": parts[1],
+                            "used": parts[2],
+                            "free": parts[3],
+                            "shared": parts[4],
+                            "buff_cache": parts[5],
+                            "available": parts[6],
+                        }
+            except Exception as e:
+                diagnostics["memory_usage"] = {"error": str(e)}
+
+            # 4. Docker system disk usage
+            try:
+                docker_df_result = subprocess.run(
+                    [
+                        "ssh",
+                        *ssh_opts,
+                        f"azureuser@{vm_ip}",
+                        "docker system df 2>/dev/null || echo ''",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if docker_df_result.returncode == 0 and docker_df_result.stdout.strip():
+                    lines = docker_df_result.stdout.strip().split("\n")
+                    # Parse the table: TYPE, TOTAL, ACTIVE, SIZE, RECLAIMABLE
+                    for line in lines[1:]:  # Skip header
+                        parts = line.split()
+                        if len(parts) >= 5:
+                            dtype = parts[0]
+                            diagnostics["docker_system"][dtype.lower()] = {
+                                "total": parts[1],
+                                "active": parts[2],
+                                "size": parts[3],
+                                "reclaimable": " ".join(parts[4:]),
+                            }
+            except Exception as e:
+                diagnostics["docker_system"] = {"error": str(e)}
+
+            # 5. Docker images
+            try:
+                images_result = subprocess.run(
+                    [
+                        "ssh",
+                        *ssh_opts,
+                        f"azureuser@{vm_ip}",
+                        "docker images --format '{{.Repository}}:{{.Tag}}|{{.Size}}|{{.CreatedSince}}' 2>/dev/null || echo ''",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if images_result.returncode == 0 and images_result.stdout.strip():
+                    for line in images_result.stdout.strip().split("\n"):
+                        if "|" in line:
+                            parts = line.split("|")
+                            if len(parts) >= 3:
+                                diagnostics["docker_images"].append(
+                                    {
+                                        "image": parts[0],
+                                        "size": parts[1],
+                                        "created": parts[2],
+                                    }
+                                )
+            except Exception as e:
+                diagnostics["docker_images"] = [{"error": str(e)}]
+
+            return diagnostics
+
         def _fetch_background_tasks(self):
             """Fetch status of all background tasks: Azure VM, Docker containers, benchmarks."""
             import subprocess
-            from datetime import datetime
-            import time
 
             tasks = []
 
@@ -1063,31 +1724,43 @@ def cmd_serve(args: argparse.Namespace) -> int:
             if env_vm_ip:
                 # Use environment variable - VM IP was provided directly
                 vm_ip = env_vm_ip
-                tasks.append({
-                    "task_id": "azure-vm-waa",
-                    "task_type": "vm_provision",
-                    "status": "completed",
-                    "phase": "ready",  # Match status to prevent "Starting" + "completed" conflict
-                    "title": "Azure VM Host",
-                    "description": f"Linux host running at {vm_ip}",
-                    "progress_percent": 100.0,
-                    "elapsed_seconds": 0,
-                    "metadata": {
-                        "vm_name": "waa-eval-vm",
-                        "ip_address": vm_ip,
-                        "internal_ip": env_internal_ip
+                tasks.append(
+                    {
+                        "task_id": "azure-vm-waa",
+                        "task_type": "vm_provision",
+                        "status": "completed",
+                        "phase": "ready",  # Match status to prevent "Starting" + "completed" conflict
+                        "title": "Azure VM Host",
+                        "description": f"Linux host running at {vm_ip}",
+                        "progress_percent": 100.0,
+                        "elapsed_seconds": 0,
+                        "metadata": {
+                            "vm_name": "waa-eval-vm",
+                            "ip_address": vm_ip,
+                            "internal_ip": env_internal_ip,
+                        },
                     }
-                })
+                )
             else:
                 # Query Azure CLI for VM status
                 try:
                     result = subprocess.run(
-                        ["az", "vm", "get-instance-view",
-                         "--name", "waa-eval-vm",
-                         "--resource-group", "openadapt-agents",
-                         "--query", "instanceView.statuses",
-                         "-o", "json"],
-                        capture_output=True, text=True, timeout=10
+                        [
+                            "az",
+                            "vm",
+                            "get-instance-view",
+                            "--name",
+                            "waa-eval-vm",
+                            "--resource-group",
+                            "openadapt-agents",
+                            "--query",
+                            "instanceView.statuses",
+                            "-o",
+                            "json",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
                     )
                     if result.returncode == 0:
                         statuses = json.loads(result.stdout)
@@ -1098,31 +1771,49 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                         # Get VM IP
                         ip_result = subprocess.run(
-                            ["az", "vm", "list-ip-addresses",
-                             "--name", "waa-eval-vm",
-                             "--resource-group", "openadapt-agents",
-                             "--query", "[0].virtualMachine.network.publicIpAddresses[0].ipAddress",
-                             "-o", "tsv"],
-                            capture_output=True, text=True, timeout=10
+                            [
+                                "az",
+                                "vm",
+                                "list-ip-addresses",
+                                "--name",
+                                "waa-eval-vm",
+                                "--resource-group",
+                                "openadapt-agents",
+                                "--query",
+                                "[0].virtualMachine.network.publicIpAddresses[0].ipAddress",
+                                "-o",
+                                "tsv",
+                            ],
+                            capture_output=True,
+                            text=True,
+                            timeout=10,
+                        )
+                        vm_ip = (
+                            ip_result.stdout.strip()
+                            if ip_result.returncode == 0
+                            else None
                         )
-                        vm_ip = ip_result.stdout.strip() if ip_result.returncode == 0 else None
 
                         if power_state == "running":
-                            tasks.append({
-                                "task_id": "azure-vm-waa",
-                                "task_type": "vm_provision",
-                                "status": "completed",
-                                "phase": "ready",  # Match status to prevent "Starting" + "completed" conflict
-                                "title": "Azure VM Host",
-                                "description": f"Linux host running at {vm_ip}" if vm_ip else "Linux host running",
-                                "progress_percent": 100.0,
-                                "elapsed_seconds": 0,
-                                "metadata": {
-                                    "vm_name": "waa-eval-vm",
-                                    "ip_address": vm_ip
-                                    # No VNC link - that's for the Windows container
+                            tasks.append(
+                                {
+                                    "task_id": "azure-vm-waa",
+                                    "task_type": "vm_provision",
+                                    "status": "completed",
+                                    "phase": "ready",  # Match status to prevent "Starting" + "completed" conflict
+                                    "title": "Azure VM Host",
+                                    "description": f"Linux host running at {vm_ip}"
+                                    if vm_ip
+                                    else "Linux host running",
+                                    "progress_percent": 100.0,
+                                    "elapsed_seconds": 0,
+                                    "metadata": {
+                                        "vm_name": "waa-eval-vm",
+                                        "ip_address": vm_ip,
+                                        # No VNC link - that's for the Windows container
+                                    },
                                 }
-                            })
+                            )
                 except subprocess.TimeoutExpired:
                     pass
                 except Exception:
@@ -1132,31 +1823,59 @@ def cmd_serve(args: argparse.Namespace) -> int:
             if vm_ip:
                 try:
                     docker_result = subprocess.run(
-                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                         f"azureuser@{vm_ip}",
-                         "docker ps --format '{{.Names}}|{{.Status}}|{{.Image}}'"],
-                        capture_output=True, text=True, timeout=15
+                        [
+                            "ssh",
+                            "-o",
+                            "StrictHostKeyChecking=no",
+                            "-o",
+                            "ConnectTimeout=5",
+                            "-i",
+                            str(Path.home() / ".ssh" / "id_rsa"),
+                            f"azureuser@{vm_ip}",
+                            "docker ps --format '{{.Names}}|{{.Status}}|{{.Image}}'",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=15,
                     )
                     if docker_result.returncode == 0 and docker_result.stdout.strip():
-                        for line in docker_result.stdout.strip().split('\n'):
-                            parts = line.split('|')
+                        for line in docker_result.stdout.strip().split("\n"):
+                            parts = line.split("|")
                             if len(parts) >= 3:
-                                container_name, status, image = parts[0], parts[1], parts[2]
+                                container_name, status, image = (
+                                    parts[0],
+                                    parts[1],
+                                    parts[2],
+                                )
                                 # Parse "Up X minutes" to determine if healthy
-                                is_healthy = "Up" in status
 
                                 # Check for Windows VM specifically
-                                if "windows" in image.lower() or container_name == "winarena":
+                                if (
+                                    "windows" in image.lower()
+                                    or container_name == "winarena"
+                                ):
                                     # Get detailed progress from docker logs
                                     log_check = subprocess.run(
-                                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                                         f"azureuser@{vm_ip}",
-                                         f"docker logs {container_name} 2>&1 | tail -30"],
-                                        capture_output=True, text=True, timeout=10
+                                        [
+                                            "ssh",
+                                            "-o",
+                                            "StrictHostKeyChecking=no",
+                                            "-o",
+                                            "ConnectTimeout=5",
+                                            "-i",
+                                            str(Path.home() / ".ssh" / "id_rsa"),
+                                            f"azureuser@{vm_ip}",
+                                            f"docker logs {container_name} 2>&1 | tail -30",
+                                        ],
+                                        capture_output=True,
+                                        text=True,
+                                        timeout=10,
+                                    )
+                                    logs = (
+                                        log_check.stdout
+                                        if log_check.returncode == 0
+                                        else ""
                                     )
-                                    logs = log_check.stdout if log_check.returncode == 0 else ""
 
                                     # Parse progress from logs
                                     phase = "unknown"
@@ -1167,17 +1886,32 @@ def cmd_serve(args: argparse.Namespace) -> int:
                                         # Check if WAA server is ready via Docker port forwarding
                                         # See docs/waa_network_architecture.md - always use localhost
                                         server_check = subprocess.run(
-                                            ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                                             "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                                             f"azureuser@{vm_ip}",
-                                             "curl -s --connect-timeout 2 http://localhost:5000/probe 2>/dev/null"],
-                                            capture_output=True, text=True, timeout=10
+                                            [
+                                                "ssh",
+                                                "-o",
+                                                "StrictHostKeyChecking=no",
+                                                "-o",
+                                                "ConnectTimeout=5",
+                                                "-i",
+                                                str(Path.home() / ".ssh" / "id_rsa"),
+                                                f"azureuser@{vm_ip}",
+                                                "curl -s --connect-timeout 2 http://localhost:5000/probe 2>/dev/null",
+                                            ],
+                                            capture_output=True,
+                                            text=True,
+                                            timeout=10,
+                                        )
+                                        waa_ready = (
+                                            server_check.returncode == 0
+                                            and "Service is operational"
+                                            in server_check.stdout
                                         )
-                                        waa_ready = server_check.returncode == 0 and "Service is operational" in server_check.stdout
                                         if waa_ready:
                                             phase = "ready"
                                             progress = 100.0
-                                            description = "WAA Server ready - benchmarks can run"
+                                            description = (
+                                                "WAA Server ready - benchmarks can run"
+                                            )
                                         else:
                                             phase = "oobe"
                                             progress = 80.0  # Phase 5/6 - VM install in progress
@@ -1186,10 +1920,15 @@ def cmd_serve(args: argparse.Namespace) -> int:
                                         phase = "booting"
                                         progress = 70.0  # Phase 4/6
                                         description = "Phase 4/6: Booting Windows from installer..."
-                                    elif "Building Windows" in logs or "Creating a" in logs:
+                                    elif (
+                                        "Building Windows" in logs
+                                        or "Creating a" in logs
+                                    ):
                                         phase = "building"
                                         progress = 60.0  # Phase 3/6
-                                        description = "Phase 3/6: Building Windows VM disk..."
+                                        description = (
+                                            "Phase 3/6: Building Windows VM disk..."
+                                        )
                                     elif "Adding" in logs and "image" in logs:
                                         phase = "configuring"
                                         progress = 50.0  # Phase 2/6
@@ -1197,15 +1936,22 @@ def cmd_serve(args: argparse.Namespace) -> int:
                                     elif "Extracting" in logs:
                                         phase = "extracting"
                                         progress = 35.0  # Phase 1/6 (after download)
-                                        description = "Phase 1/6: Extracting Windows ISO..."
+                                        description = (
+                                            "Phase 1/6: Extracting Windows ISO..."
+                                        )
                                     else:
                                         # Check for download progress (e.g., "1234K ........ 45% 80M 30s")
                                         import re
-                                        download_match = re.search(r'(\d+)%\s+[\d.]+[KMG]\s+(\d+)s', logs)
+
+                                        download_match = re.search(
+                                            r"(\d+)%\s+[\d.]+[KMG]\s+(\d+)s", logs
+                                        )
                                         if download_match:
                                             phase = "downloading"
                                             dl_pct = float(download_match.group(1))
-                                            progress = dl_pct * 0.30  # 0-30% for download phase
+                                            progress = (
+                                                dl_pct * 0.30
+                                            )  # 0-30% for download phase
                                             eta = download_match.group(2)
                                             description = f"Phase 0/6: Downloading Windows 11... {download_match.group(1)}% ({eta}s left)"
 
@@ -1218,40 +1964,61 @@ def cmd_serve(args: argparse.Namespace) -> int:
                                         progress = 90.0
 
                                     # Get detailed metadata for VM Details panel
-                                    vm_metadata = self._get_vm_detailed_metadata(vm_ip, container_name, logs, phase)
-
-                                    tasks.append({
-                                        "task_id": f"docker-{container_name}",
-                                        "task_type": "docker_container",
-                                        "status": "completed" if phase == "ready" else "running",
-                                        "title": "Windows 11 + WAA Server",
-                                        "description": description,
-                                        "progress_percent": progress,
-                                        "elapsed_seconds": 0,
-                                        "phase": phase,
-                                        "metadata": {
-                                            "container": container_name,
-                                            "image": image,
-                                            "status": status,
+                                    vm_metadata = self._get_vm_detailed_metadata(
+                                        vm_ip, container_name, logs, phase
+                                    )
+
+                                    tasks.append(
+                                        {
+                                            "task_id": f"docker-{container_name}",
+                                            "task_type": "docker_container",
+                                            "status": "completed"
+                                            if phase == "ready"
+                                            else "running",
+                                            "title": "Windows 11 + WAA Server",
+                                            "description": description,
+                                            "progress_percent": progress,
+                                            "elapsed_seconds": 0,
                                             "phase": phase,
-                                            "windows_ready": phase in ["oobe", "ready"],
-                                            "waa_server_ready": phase == "ready",
-                                            # Use localhost - SSH tunnel handles routing to VM
-                                            # See docs/waa_network_architecture.md
-                                            "vnc_url": "http://localhost:8006",
-                                            "windows_username": "Docker",
-                                            "windows_password": "admin",
-                                            "recent_logs": logs[-500:] if logs else "",
-                                            # Enhanced VM details
-                                            "disk_usage_gb": vm_metadata["disk_usage_gb"],
-                                            "memory_usage_mb": vm_metadata["memory_usage_mb"],
-                                            "setup_script_phase": vm_metadata["setup_script_phase"],
-                                            "probe_response": vm_metadata["probe_response"],
-                                            "qmp_connected": vm_metadata["qmp_connected"],
-                                            "dependencies": vm_metadata["dependencies"],
+                                            "metadata": {
+                                                "container": container_name,
+                                                "image": image,
+                                                "status": status,
+                                                "phase": phase,
+                                                "windows_ready": phase
+                                                in ["oobe", "ready"],
+                                                "waa_server_ready": phase == "ready",
+                                                # Use localhost - SSH tunnel handles routing to VM
+                                                # See docs/waa_network_architecture.md
+                                                "vnc_url": "http://localhost:8006",
+                                                "windows_username": "Docker",
+                                                "windows_password": "admin",
+                                                "recent_logs": logs[-500:]
+                                                if logs
+                                                else "",
+                                                # Enhanced VM details
+                                                "disk_usage_gb": vm_metadata[
+                                                    "disk_usage_gb"
+                                                ],
+                                                "memory_usage_mb": vm_metadata[
+                                                    "memory_usage_mb"
+                                                ],
+                                                "setup_script_phase": vm_metadata[
+                                                    "setup_script_phase"
+                                                ],
+                                                "probe_response": vm_metadata[
+                                                    "probe_response"
+                                                ],
+                                                "qmp_connected": vm_metadata[
+                                                    "qmp_connected"
+                                                ],
+                                                "dependencies": vm_metadata[
+                                                    "dependencies"
+                                                ],
+                                            },
                                         }
-                                    })
-                except Exception as e:
+                                    )
+                except Exception:
                     # SSH failed, VM might still be starting
                     pass
 
@@ -1261,38 +2028,93 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 try:
                     progress = json.loads(progress_file.read_text())
                     if progress.get("status") == "running":
-                        tasks.append({
-                            "task_id": "benchmark-local",
-                            "task_type": "benchmark_run",
-                            "status": "running",
-                            "title": f"{progress.get('provider', 'API').upper()} Benchmark",
-                            "description": progress.get("message", "Running benchmark..."),
-                            "progress_percent": (progress.get("tasks_complete", 0) / max(progress.get("tasks_total", 1), 1)) * 100,
-                            "elapsed_seconds": 0,
-                            "metadata": progress
-                        })
+                        tasks.append(
+                            {
+                                "task_id": "benchmark-local",
+                                "task_type": "benchmark_run",
+                                "status": "running",
+                                "title": f"{progress.get('provider', 'API').upper()} Benchmark",
+                                "description": progress.get(
+                                    "message", "Running benchmark..."
+                                ),
+                                "progress_percent": (
+                                    progress.get("tasks_complete", 0)
+                                    / max(progress.get("tasks_total", 1), 1)
+                                )
+                                * 100,
+                                "elapsed_seconds": 0,
+                                "metadata": progress,
+                            }
+                        )
                 except Exception:
                     pass
 
             return tasks
 
         def _fetch_vm_registry(self):
-            """Fetch VM registry with live status checks."""
+            """Fetch VM registry with live status checks.
+
+            NOTE: We now fetch the VM IP from Azure CLI at runtime to avoid
+            stale IP issues. The registry file is only used as a fallback.
+            """
             import subprocess
             from datetime import datetime
 
-            # Path to VM registry file (relative to project root)
-            project_root = Path(__file__).parent.parent.parent
-            registry_file = project_root / "benchmark_results" / "vm_registry.json"
+            # Try to get VM IP from Azure CLI (always fresh)
+            vm_ip = None
+            resource_group = "openadapt-agents"
+            vm_name = "azure-waa-vm"
+            try:
+                result = subprocess.run(
+                    [
+                        "az",
+                        "vm",
+                        "show",
+                        "-d",
+                        "-g",
+                        resource_group,
+                        "-n",
+                        vm_name,
+                        "--query",
+                        "publicIps",
+                        "-o",
+                        "tsv",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    vm_ip = result.stdout.strip()
+            except Exception:
+                pass
 
-            if not registry_file.exists():
-                return []
+            # If we have a fresh IP from Azure, use it
+            if vm_ip:
+                vms = [
+                    {
+                        "name": vm_name,
+                        "ssh_host": vm_ip,
+                        "ssh_user": "azureuser",
+                        "vnc_port": 8006,
+                        "waa_port": 5000,
+                        "docker_container": "winarena",
+                        "internal_ip": "localhost",
+                    }
+                ]
+            else:
+                # Fallback to registry file
+                project_root = Path(__file__).parent.parent.parent
+                registry_file = project_root / "benchmark_results" / "vm_registry.json"
 
-            try:
-                with open(registry_file) as f:
-                    vms = json.load(f)
-            except Exception as e:
-                return {"error": f"Failed to read VM registry: {e}"}
+                if not registry_file.exists():
+                    return []
+
+                try:
+                    with open(registry_file) as f:
+                        vms = json.load(f)
+                except Exception as e:
+                    return {"error": f"Failed to read VM registry: {e}"}
 
             # Check status for each VM
             for vm in vms:
@@ -1306,7 +2128,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     vnc_url = f"http://{vm['ssh_host']}:{vm['vnc_port']}"
                     result = subprocess.run(
                         ["curl", "-I", "-s", "--connect-timeout", "3", vnc_url],
-                        capture_output=True, text=True, timeout=5
+                        capture_output=True,
+                        text=True,
+                        timeout=5,
                     )
                     if result.returncode == 0 and "200" in result.stdout:
                         vm["vnc_reachable"] = True
@@ -1320,13 +2144,25 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     waa_port = vm.get("waa_port", 5000)
                     ssh_cmd = f"curl -s --connect-timeout 2 http://localhost:{waa_port}/probe 2>/dev/null"
                     result = subprocess.run(
-                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=3",
-                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                         f"{vm['ssh_user']}@{vm['ssh_host']}",
-                         ssh_cmd],
-                        capture_output=True, text=True, timeout=5
+                        [
+                            "ssh",
+                            "-o",
+                            "StrictHostKeyChecking=no",
+                            "-o",
+                            "ConnectTimeout=3",
+                            "-i",
+                            str(Path.home() / ".ssh" / "id_rsa"),
+                            f"{vm['ssh_user']}@{vm['ssh_host']}",
+                            ssh_cmd,
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=5,
+                    )
+                    probe_success = (
+                        result.returncode == 0
+                        and "Service is operational" in result.stdout
                     )
-                    probe_success = result.returncode == 0 and "Service is operational" in result.stdout
                     if probe_success:
                         vm["waa_probe_status"] = "ready"
                         vm["status"] = "online"
@@ -1338,7 +2174,11 @@ def cmd_serve(args: argparse.Namespace) -> int:
                                 ssh_user=vm.get("ssh_user", "azureuser"),
                             )
                             vm["tunnels"] = {
-                                name: {"active": s.active, "local_port": s.local_port, "error": s.error}
+                                name: {
+                                    "active": s.active,
+                                    "local_port": s.local_port,
+                                    "error": s.error,
+                                }
                                 for name, s in tunnel_status.items()
                             }
                         except Exception as e:
@@ -1384,12 +2224,22 @@ def cmd_serve(args: argparse.Namespace) -> int:
             # First get VM IP
             try:
                 ip_result = subprocess.run(
-                    ["az", "vm", "list-ip-addresses",
-                     "--name", "waa-eval-vm",
-                     "--resource-group", "openadapt-agents",
-                     "--query", "[0].virtualMachine.network.publicIpAddresses[0].ipAddress",
-                     "-o", "tsv"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "az",
+                        "vm",
+                        "list-ip-addresses",
+                        "--name",
+                        "waa-eval-vm",
+                        "--resource-group",
+                        "openadapt-agents",
+                        "--query",
+                        "[0].virtualMachine.network.publicIpAddresses[0].ipAddress",
+                        "-o",
+                        "tsv",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
                 if ip_result.returncode == 0 and ip_result.stdout.strip():
                     vm_ip = ip_result.stdout.strip()
@@ -1398,11 +2248,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     # Try to probe WAA server via SSH
                     # Use the correct internal IP for the Windows VM inside Docker
                     probe_result = subprocess.run(
-                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                         f"azureuser@{vm_ip}",
-                         "docker exec waa-container curl -s --connect-timeout 3 http://172.30.0.2:5000/probe 2>/dev/null || echo 'probe_failed'"],
-                        capture_output=True, text=True, timeout=15
+                        [
+                            "ssh",
+                            "-o",
+                            "StrictHostKeyChecking=no",
+                            "-o",
+                            "ConnectTimeout=5",
+                            "-i",
+                            str(Path.home() / ".ssh" / "id_rsa"),
+                            f"azureuser@{vm_ip}",
+                            "docker exec waa-container curl -s --connect-timeout 3 http://172.30.0.2:5000/probe 2>/dev/null || echo 'probe_failed'",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=15,
                     )
 
                     result["container"] = "waa-container"
@@ -1415,7 +2274,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
                         else:
                             result["probe_result"] = "WAA server not responding"
                     else:
-                        result["probe_result"] = f"SSH/Docker error: {probe_result.stderr[:200]}"
+                        result["probe_result"] = (
+                            f"SSH/Docker error: {probe_result.stderr[:200]}"
+                        )
                 else:
                     result["probe_result"] = "Could not get VM IP"
             except subprocess.TimeoutExpired:
@@ -1443,7 +2304,6 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 - elapsed_minutes: int
             """
             import subprocess
-            from datetime import datetime
             import re
 
             result = {
@@ -1465,8 +2325,12 @@ def cmd_serve(args: argparse.Namespace) -> int:
                         result["running"] = True
                         result["type"] = "local"
                         result["model"] = progress.get("provider", "unknown")
-                        result["progress"]["tasks_completed"] = progress.get("tasks_complete", 0)
-                        result["progress"]["total_tasks"] = progress.get("tasks_total", 0)
+                        result["progress"]["tasks_completed"] = progress.get(
+                            "tasks_complete", 0
+                        )
+                        result["progress"]["total_tasks"] = progress.get(
+                            "tasks_total", 0
+                        )
                         return result
                 except Exception:
                     pass
@@ -1475,12 +2339,22 @@ def cmd_serve(args: argparse.Namespace) -> int:
             try:
                 # Get VM IP
                 ip_result = subprocess.run(
-                    ["az", "vm", "list-ip-addresses",
-                     "--name", "waa-eval-vm",
-                     "--resource-group", "openadapt-agents",
-                     "--query", "[0].virtualMachine.network.publicIpAddresses[0].ipAddress",
-                     "-o", "tsv"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "az",
+                        "vm",
+                        "list-ip-addresses",
+                        "--name",
+                        "waa-eval-vm",
+                        "--resource-group",
+                        "openadapt-agents",
+                        "--query",
+                        "[0].virtualMachine.network.publicIpAddresses[0].ipAddress",
+                        "-o",
+                        "tsv",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
 
                 if ip_result.returncode == 0 and ip_result.stdout.strip():
@@ -1488,42 +2362,73 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                     # Check if benchmark process is running
                     process_check = subprocess.run(
-                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                         f"azureuser@{vm_ip}",
-                         "docker exec waa-container pgrep -f 'python.*run.py' 2>/dev/null && echo 'RUNNING' || echo 'NOT_RUNNING'"],
-                        capture_output=True, text=True, timeout=10
+                        [
+                            "ssh",
+                            "-o",
+                            "StrictHostKeyChecking=no",
+                            "-o",
+                            "ConnectTimeout=5",
+                            "-i",
+                            str(Path.home() / ".ssh" / "id_rsa"),
+                            f"azureuser@{vm_ip}",
+                            "docker exec waa-container pgrep -f 'python.*run.py' 2>/dev/null && echo 'RUNNING' || echo 'NOT_RUNNING'",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
                     )
 
-                    if process_check.returncode == 0 and "RUNNING" in process_check.stdout:
+                    if (
+                        process_check.returncode == 0
+                        and "RUNNING" in process_check.stdout
+                    ):
                         result["running"] = True
                         result["type"] = "azure_vm"
 
                         # Get log file for more details
                         log_check = subprocess.run(
-                            ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                             "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                             f"azureuser@{vm_ip}",
-                             "tail -100 /tmp/waa_benchmark.log 2>/dev/null || echo ''"],
-                            capture_output=True, text=True, timeout=10
+                            [
+                                "ssh",
+                                "-o",
+                                "StrictHostKeyChecking=no",
+                                "-o",
+                                "ConnectTimeout=5",
+                                "-i",
+                                str(Path.home() / ".ssh" / "id_rsa"),
+                                f"azureuser@{vm_ip}",
+                                "tail -100 /tmp/waa_benchmark.log 2>/dev/null || echo ''",
+                            ],
+                            capture_output=True,
+                            text=True,
+                            timeout=10,
                         )
 
                         if log_check.returncode == 0 and log_check.stdout.strip():
                             logs = log_check.stdout
 
                             # Parse model from logs
-                            model_match = re.search(r'model[=:\s]+([^\s,]+)', logs, re.IGNORECASE)
+                            model_match = re.search(
+                                r"model[=:\s]+([^\s,]+)", logs, re.IGNORECASE
+                            )
                             if model_match:
                                 result["model"] = model_match.group(1)
 
                             # Parse progress
-                            task_match = re.search(r'Task\s+(\d+)/(\d+)', logs)
+                            task_match = re.search(r"Task\s+(\d+)/(\d+)", logs)
                             if task_match:
-                                result["progress"]["tasks_completed"] = int(task_match.group(1))
-                                result["progress"]["total_tasks"] = int(task_match.group(2))
+                                result["progress"]["tasks_completed"] = int(
+                                    task_match.group(1)
+                                )
+                                result["progress"]["total_tasks"] = int(
+                                    task_match.group(2)
+                                )
 
                             # Parse current task
-                            task_id_match = re.search(r'(?:Running|Processing|task)[:\s]+([a-f0-9-]+)', logs, re.IGNORECASE)
+                            task_id_match = re.search(
+                                r"(?:Running|Processing|task)[:\s]+([a-f0-9-]+)",
+                                logs,
+                                re.IGNORECASE,
+                            )
                             if task_id_match:
                                 result["current_task"] = task_id_match.group(1)
 
@@ -1532,7 +2437,284 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
             return result
 
-        async def _detect_running_benchmark(self, vm_ip: str, container_name: str = "winarena") -> dict:
+        def _get_benchmark_status(self) -> dict:
+            """Get current benchmark job status with ETA calculation.
+
+            Returns:
+                dict with job status, progress, ETA, and current task info
+            """
+            import time
+
+            # Check for live evaluation state
+            live_file = Path("benchmark_live.json")
+            if live_file.exists():
+                try:
+                    live_state = json.loads(live_file.read_text())
+                    if live_state.get("status") == "running":
+                        total_tasks = live_state.get("total_tasks", 0)
+                        completed_tasks = live_state.get("tasks_completed", 0)
+                        current_task = live_state.get("current_task", {})
+
+                        # Calculate ETA based on completed tasks
+                        eta_seconds = None
+                        avg_task_seconds = None
+                        if completed_tasks > 0 and total_tasks > 0:
+                            # Estimate from live state timestamp or use fallback
+                            elapsed = time.time() - live_state.get(
+                                "start_time", time.time()
+                            )
+                            avg_task_seconds = (
+                                elapsed / completed_tasks
+                                if completed_tasks > 0
+                                else 30.0
+                            )
+                            remaining_tasks = total_tasks - completed_tasks
+                            eta_seconds = remaining_tasks * avg_task_seconds
+
+                        return {
+                            "status": "running",
+                            "current_job": {
+                                "run_id": live_state.get("run_id", "unknown"),
+                                "model_id": live_state.get("model_id", "unknown"),
+                                "total_tasks": total_tasks,
+                                "completed_tasks": completed_tasks,
+                                "current_task": current_task,
+                                "eta_seconds": eta_seconds,
+                                "avg_task_seconds": avg_task_seconds,
+                            },
+                            "queue": [],  # TODO: implement queue tracking
+                        }
+                except Exception as e:
+                    return {"status": "error", "error": str(e)}
+
+            # Fallback to current_run check
+            current_run = self._get_current_run()
+            if current_run.get("running"):
+                return {
+                    "status": "running",
+                    "current_job": {
+                        "run_id": "unknown",
+                        "model_id": current_run.get("model", "unknown"),
+                        "total_tasks": current_run["progress"]["total_tasks"],
+                        "completed_tasks": current_run["progress"]["tasks_completed"],
+                        "current_task": {"task_id": current_run.get("current_task")},
+                    },
+                    "queue": [],
+                }
+
+            return {"status": "idle"}
+
+        def _get_benchmark_costs(self) -> dict:
+            """Get cost breakdown for current benchmark run.
+
+            Returns:
+                dict with Azure VM, API calls, and GPU costs
+            """
+
+            # Check for cost tracking file
+            cost_file = Path("benchmark_costs.json")
+            if cost_file.exists():
+                try:
+                    return json.loads(cost_file.read_text())
+                except Exception:
+                    pass
+
+            # Return placeholder structure
+            return {
+                "azure_vm": {
+                    "instance_type": "Standard_D4ds_v5",
+                    "hourly_rate_usd": 0.192,
+                    "hours_elapsed": 0.0,
+                    "cost_usd": 0.0,
+                },
+                "api_calls": {
+                    "anthropic": {"cost_usd": 0.0},
+                    "openai": {"cost_usd": 0.0},
+                },
+                "gpu_time": {
+                    "lambda_labs": {"cost_usd": 0.0},
+                },
+                "total_cost_usd": 0.0,
+            }
+
+        def _get_benchmark_metrics(self) -> dict:
+            """Get performance metrics for current/completed benchmarks.
+
+            Returns:
+                dict with success rate trends, domain breakdown, episode metrics
+            """
+            # Check for metrics file
+            metrics_file = Path("benchmark_metrics.json")
+            if metrics_file.exists():
+                try:
+                    return json.loads(metrics_file.read_text())
+                except Exception:
+                    pass
+
+            # Load completed runs from benchmark_results/
+            benchmark_results_dir = Path("benchmark_results")
+            if not benchmark_results_dir.exists():
+                return {"error": "No benchmark results found"}
+
+            # Find most recent run
+            runs = sorted(
+                benchmark_results_dir.iterdir(),
+                key=lambda p: p.stat().st_mtime,
+                reverse=True,
+            )
+            if not runs:
+                return {"error": "No benchmark runs found"}
+
+            recent_run = runs[0]
+            summary_path = recent_run / "summary.json"
+            if not summary_path.exists():
+                return {"error": f"No summary.json in {recent_run.name}"}
+
+            try:
+                summary = json.loads(summary_path.read_text())
+
+                # Build domain breakdown from tasks
+                domain_breakdown = {}
+                tasks_dir = recent_run / "tasks"
+                if tasks_dir.exists():
+                    for task_dir in tasks_dir.iterdir():
+                        if not task_dir.is_dir():
+                            continue
+
+                        task_json = task_dir / "task.json"
+                        execution_json = task_dir / "execution.json"
+                        if not (task_json.exists() and execution_json.exists()):
+                            continue
+
+                        try:
+                            task_def = json.loads(task_json.read_text())
+                            execution = json.loads(execution_json.read_text())
+
+                            domain = task_def.get("domain", "unknown")
+                            if domain not in domain_breakdown:
+                                domain_breakdown[domain] = {
+                                    "total": 0,
+                                    "success": 0,
+                                    "rate": 0.0,
+                                    "avg_steps": 0.0,
+                                    "total_steps": 0,
+                                }
+
+                            domain_breakdown[domain]["total"] += 1
+                            if execution.get("success"):
+                                domain_breakdown[domain]["success"] += 1
+                            domain_breakdown[domain]["total_steps"] += execution.get(
+                                "num_steps", 0
+                            )
+
+                        except Exception:
+                            continue
+
+                # Calculate averages
+                for domain, stats in domain_breakdown.items():
+                    if stats["total"] > 0:
+                        stats["rate"] = stats["success"] / stats["total"]
+                        stats["avg_steps"] = stats["total_steps"] / stats["total"]
+
+                return {
+                    "success_rate_over_time": [],  # TODO: implement trend tracking
+                    "avg_steps_per_task": [],  # TODO: implement trend tracking
+                    "domain_breakdown": domain_breakdown,
+                    "episode_success_metrics": {
+                        "first_action_accuracy": summary.get(
+                            "first_action_accuracy", 0.0
+                        ),
+                        "episode_success_rate": summary.get("success_rate", 0.0),
+                        "avg_steps_to_success": summary.get("avg_steps", 0.0),
+                        "avg_steps_to_failure": 0.0,  # TODO: calculate from failed tasks
+                    },
+                }
+            except Exception as e:
+                return {"error": f"Failed to load metrics: {str(e)}"}
+
+        def _get_benchmark_workers(self) -> dict:
+            """Get worker status and utilization.
+
+            Returns:
+                dict with total/active/idle workers and per-worker stats
+            """
+            # Get VM registry
+            vms = self._fetch_vm_registry()
+
+            active_workers = [v for v in vms if v.get("status") == "online"]
+            idle_workers = [v for v in vms if v.get("status") != "online"]
+
+            workers = []
+            for vm in vms:
+                workers.append(
+                    {
+                        "worker_id": vm.get("name", "unknown"),
+                        "status": "running" if vm.get("status") == "online" else "idle",
+                        "current_task": vm.get("current_task"),
+                        "tasks_completed": vm.get("tasks_completed", 0),
+                        "uptime_seconds": vm.get("uptime_seconds", 0),
+                        "idle_time_seconds": vm.get("idle_time_seconds", 0),
+                    }
+                )
+
+            return {
+                "total_workers": len(vms),
+                "active_workers": len(active_workers),
+                "idle_workers": len(idle_workers),
+                "workers": workers,
+            }
+
+        def _get_benchmark_runs(self) -> list[dict]:
+            """Load all benchmark runs from benchmark_results directory.
+
+            Returns:
+                List of benchmark run summaries sorted by timestamp (newest first)
+            """
+            results_dir = Path("benchmark_results")
+            if not results_dir.exists():
+                return []
+
+            runs = []
+            for run_dir in results_dir.iterdir():
+                if run_dir.is_dir():
+                    summary_file = run_dir / "summary.json"
+                    if summary_file.exists():
+                        try:
+                            summary = json.loads(summary_file.read_text())
+                            runs.append(summary)
+                        except (json.JSONDecodeError, IOError) as e:
+                            print(f"Warning: Failed to load {summary_file}: {e}")
+
+            # Sort by run_name descending (newest first)
+            runs.sort(key=lambda r: r.get("run_name", ""), reverse=True)
+            return runs
+
+        def _get_task_execution(self, run_name: str, task_id: str) -> dict:
+            """Load task execution details from execution.json.
+
+            Args:
+                run_name: Name of the benchmark run
+                task_id: Task identifier
+
+            Returns:
+                Task execution data with steps and screenshots
+            """
+            results_dir = Path("benchmark_results")
+            execution_file = (
+                results_dir / run_name / "tasks" / task_id / "execution.json"
+            )
+
+            if not execution_file.exists():
+                raise FileNotFoundError(f"Execution file not found: {execution_file}")
+
+            try:
+                return json.loads(execution_file.read_text())
+            except (json.JSONDecodeError, IOError) as e:
+                raise Exception(f"Failed to load execution data: {e}")
+
+        async def _detect_running_benchmark(
+            self, vm_ip: str, container_name: str = "winarena"
+        ) -> dict:
             """Detect if a benchmark is running on the VM and extract progress.
 
             SSH into VM and check:
@@ -1563,11 +2745,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
             try:
                 # Check if benchmark process is running
                 process_check = subprocess.run(
-                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                     "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                     f"azureuser@{vm_ip}",
-                     f"docker exec {container_name} pgrep -f 'python.*run.py' 2>/dev/null || echo ''"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "ConnectTimeout=5",
+                        "-i",
+                        str(Path.home() / ".ssh" / "id_rsa"),
+                        f"azureuser@{vm_ip}",
+                        f"docker exec {container_name} pgrep -f 'python.*run.py' 2>/dev/null || echo ''",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
 
                 if process_check.returncode == 0 and process_check.stdout.strip():
@@ -1575,11 +2766,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                     # Get benchmark log
                     log_check = subprocess.run(
-                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                         f"azureuser@{vm_ip}",
-                         "tail -100 /tmp/waa_benchmark.log 2>/dev/null || echo ''"],
-                        capture_output=True, text=True, timeout=10
+                        [
+                            "ssh",
+                            "-o",
+                            "StrictHostKeyChecking=no",
+                            "-o",
+                            "ConnectTimeout=5",
+                            "-i",
+                            str(Path.home() / ".ssh" / "id_rsa"),
+                            f"azureuser@{vm_ip}",
+                            "tail -100 /tmp/waa_benchmark.log 2>/dev/null || echo ''",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
                     )
 
                     if log_check.returncode == 0 and log_check.stdout.strip():
@@ -1588,22 +2788,28 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                         # Parse progress from logs
                         # Look for patterns like "Task 5/30" or "Completed: 5, Remaining: 25"
-                        task_match = re.search(r'Task\s+(\d+)/(\d+)', logs)
+                        task_match = re.search(r"Task\s+(\d+)/(\d+)", logs)
                         if task_match:
-                            result["progress"]["tasks_completed"] = int(task_match.group(1))
+                            result["progress"]["tasks_completed"] = int(
+                                task_match.group(1)
+                            )
                             result["progress"]["total_tasks"] = int(task_match.group(2))
 
                         # Extract current task ID
-                        task_id_match = re.search(r'(?:Running|Processing) task:\s*(\S+)', logs)
+                        task_id_match = re.search(
+                            r"(?:Running|Processing) task:\s*(\S+)", logs
+                        )
                         if task_id_match:
                             result["current_task"] = task_id_match.group(1)
 
                         # Extract step info
-                        step_match = re.search(r'Step\s+(\d+)', logs)
+                        step_match = re.search(r"Step\s+(\d+)", logs)
                         if step_match:
-                            result["progress"]["current_step"] = int(step_match.group(1))
+                            result["progress"]["current_step"] = int(
+                                step_match.group(1)
+                            )
 
-            except Exception as e:
+            except Exception:
                 # SSH or parsing failed - leave defaults
                 pass
 
@@ -1627,13 +2833,13 @@ def cmd_serve(args: argparse.Namespace) -> int:
             # Search backwards from most recent
             for line in reversed(log_lines):
                 # Check for explicit result
-                if 'Result: PASS' in line or 'completed successfully' in line:
+                if "Result: PASS" in line or "completed successfully" in line:
                     success = True
-                elif 'Result: FAIL' in line or 'failed' in line.lower():
+                elif "Result: FAIL" in line or "failed" in line.lower():
                     success = False
 
                 # Check for score
-                score_match = re.search(r'Score:\s*([\d.]+)', line)
+                score_match = re.search(r"Score:\s*([\d.]+)", line)
                 if score_match:
                     try:
                         score = float(score_match.group(1))
@@ -1642,9 +2848,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                 # Check for task-specific completion
                 if task_id in line:
-                    if 'success' in line.lower() or 'pass' in line.lower():
+                    if "success" in line.lower() or "pass" in line.lower():
                         success = True
-                    elif 'fail' in line.lower() or 'error' in line.lower():
+                    elif "fail" in line.lower() or "error" in line.lower():
                         success = False
 
             # Default to True if no explicit failure found (backwards compatible)
@@ -1674,11 +2880,11 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
             # Set SSE headers
             self.send_response(200)
-            self.send_header('Content-Type', 'text/event-stream')
-            self.send_header('Cache-Control', 'no-cache')
-            self.send_header('Access-Control-Allow-Origin', '*')
-            self.send_header('Connection', 'keep-alive')
-            self.send_header('X-Accel-Buffering', 'no')  # Disable nginx buffering
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-cache")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Connection", "keep-alive")
+            self.send_header("X-Accel-Buffering", "no")  # Disable nginx buffering
             self.end_headers()
 
             # Track connection state
@@ -1691,7 +2897,7 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     return False
                 try:
                     event_str = f"event: {event_type}\ndata: {json.dumps(data)}\n\n"
-                    self.wfile.write(event_str.encode('utf-8'))
+                    self.wfile.write(event_str.encode("utf-8"))
                     self.wfile.flush()
                     return True
                 except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
@@ -1734,11 +2940,10 @@ def cmd_serve(args: argparse.Namespace) -> int:
             recent_log_lines = []
 
             # Send initial connected event
-            if not send_event("connected", {
-                "timestamp": time.time(),
-                "interval": interval,
-                "version": "1.0"
-            }):
+            if not send_event(
+                "connected",
+                {"timestamp": time.time(), "interval": interval, "version": "1.0"},
+            ):
                 return
 
             try:
@@ -1763,17 +2968,25 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     tasks = self._fetch_background_tasks()
 
                     # Send VM status event
-                    vm_task = next((t for t in tasks if t.get("task_type") == "docker_container"), None)
+                    vm_task = next(
+                        (t for t in tasks if t.get("task_type") == "docker_container"),
+                        None,
+                    )
                     if vm_task:
                         vm_data = {
                             "type": "vm_status",
-                            "connected": vm_task.get("status") in ["running", "completed"],
+                            "connected": vm_task.get("status")
+                            in ["running", "completed"],
                             "phase": vm_task.get("phase", "unknown"),
-                            "waa_ready": vm_task.get("metadata", {}).get("waa_server_ready", False),
+                            "waa_ready": vm_task.get("metadata", {}).get(
+                                "waa_server_ready", False
+                            ),
                             "probe": {
-                                "status": vm_task.get("metadata", {}).get("probe_response", "unknown"),
+                                "status": vm_task.get("metadata", {}).get(
+                                    "probe_response", "unknown"
+                                ),
                                 "vnc_url": vm_task.get("metadata", {}).get("vnc_url"),
-                            }
+                            },
                         }
 
                         if not send_event("status", vm_data):
@@ -1783,27 +2996,47 @@ def cmd_serve(args: argparse.Namespace) -> int:
                         if vm_data["waa_ready"]:
                             # Get VM IP from tasks
                             vm_ip = None
-                            azure_vm = next((t for t in tasks if t.get("task_type") == "vm_provision"), None)
+                            azure_vm = next(
+                                (
+                                    t
+                                    for t in tasks
+                                    if t.get("task_type") == "vm_provision"
+                                ),
+                                None,
+                            )
                             if azure_vm:
                                 vm_ip = azure_vm.get("metadata", {}).get("ip_address")
 
                             if vm_ip:
                                 # Detect running benchmark using sync version
                                 benchmark_status = self._detect_running_benchmark_sync(
-                                    vm_ip, vm_task.get("metadata", {}).get("container", "winarena")
+                                    vm_ip,
+                                    vm_task.get("metadata", {}).get(
+                                        "container", "winarena"
+                                    ),
                                 )
 
                                 if benchmark_status["running"]:
                                     # Store log lines for result parsing
                                     if benchmark_status.get("recent_logs"):
-                                        recent_log_lines = benchmark_status["recent_logs"].split('\n')
+                                        recent_log_lines = benchmark_status[
+                                            "recent_logs"
+                                        ].split("\n")
 
                                     # Send progress event
                                     progress_data = {
-                                        "tasks_completed": benchmark_status["progress"]["tasks_completed"],
-                                        "total_tasks": benchmark_status["progress"]["total_tasks"],
-                                        "current_task": benchmark_status["current_task"],
-                                        "current_step": benchmark_status["progress"]["current_step"],
+                                        "tasks_completed": benchmark_status["progress"][
+                                            "tasks_completed"
+                                        ],
+                                        "total_tasks": benchmark_status["progress"][
+                                            "total_tasks"
+                                        ],
+                                        "current_task": benchmark_status[
+                                            "current_task"
+                                        ],
+                                        "current_step": benchmark_status["progress"][
+                                            "current_step"
+                                        ],
                                     }
 
                                     if not send_event("progress", progress_data):
@@ -1814,13 +3047,17 @@ def cmd_serve(args: argparse.Namespace) -> int:
                                     if current_task and current_task != last_task:
                                         if last_task is not None:
                                             # Previous task completed - parse result from logs
-                                            result = self._parse_task_result(recent_log_lines, last_task)
+                                            result = self._parse_task_result(
+                                                recent_log_lines, last_task
+                                            )
                                             complete_data = {
                                                 "task_id": last_task,
                                                 "success": result["success"],
                                                 "score": result["score"],
                                             }
-                                            if not send_event("task_complete", complete_data):
+                                            if not send_event(
+                                                "task_complete", complete_data
+                                            ):
                                                 break
 
                                         last_task = current_task
@@ -1832,7 +3069,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
                             progress = json.loads(progress_file.read_text())
                             if progress.get("status") == "running":
                                 progress_data = {
-                                    "tasks_completed": progress.get("tasks_complete", 0),
+                                    "tasks_completed": progress.get(
+                                        "tasks_complete", 0
+                                    ),
                                     "total_tasks": progress.get("tasks_total", 0),
                                     "current_task": progress.get("provider", "unknown"),
                                 }
@@ -1858,7 +3097,244 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 # Cleanup - connection is ending
                 client_connected = False
 
-        def _detect_running_benchmark_sync(self, vm_ip: str, container_name: str = "winarena") -> dict:
+        def _stream_azure_ops_updates(self):
+            """Stream Server-Sent Events for Azure operations status updates.
+
+            Monitors azure_ops_status.json for changes and streams updates.
+            Uses file modification time to detect changes efficiently.
+
+            Streams events:
+            - connected: Initial connection event
+            - status: Azure ops status update when file changes
+            - heartbeat: Keep-alive signal every 30 seconds
+            - error: Error messages
+            """
+            import time
+            import select
+            from pathlib import Path
+
+            HEARTBEAT_INTERVAL = 30  # seconds
+            CHECK_INTERVAL = 1  # Check file every second
+
+            # Set SSE headers
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-cache")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Connection", "keep-alive")
+            self.send_header("X-Accel-Buffering", "no")  # Disable nginx buffering
+            self.end_headers()
+
+            # Track connection state
+            client_connected = True
+            last_mtime = 0.0
+            last_session_mtime = 0.0
+            last_heartbeat = time.time()
+
+            def send_event(event_type: str, data: dict) -> bool:
+                """Send an SSE event. Returns False if client disconnected."""
+                nonlocal client_connected
+                if not client_connected:
+                    return False
+                try:
+                    event_str = f"event: {event_type}\ndata: {json.dumps(data)}\n\n"
+                    self.wfile.write(event_str.encode("utf-8"))
+                    self.wfile.flush()
+                    return True
+                except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+                    client_connected = False
+                    return False
+                except Exception as e:
+                    print(f"Azure ops SSE send error: {e}")
+                    client_connected = False
+                    return False
+
+            def check_client_connected() -> bool:
+                """Check if client is still connected using socket select."""
+                nonlocal client_connected
+                if not client_connected:
+                    return False
+                try:
+                    rlist, _, xlist = select.select([self.rfile], [], [self.rfile], 0)
+                    if xlist:
+                        client_connected = False
+                        return False
+                    if rlist:
+                        data = self.rfile.read(1)
+                        if not data:
+                            client_connected = False
+                            return False
+                    return True
+                except Exception:
+                    client_connected = False
+                    return False
+
+            # Status file path
+            from openadapt_ml.benchmarks.azure_ops_tracker import (
+                DEFAULT_OUTPUT_FILE,
+                read_status,
+            )
+            from openadapt_ml.benchmarks.session_tracker import (
+                get_session,
+                update_session_vm_state,
+                DEFAULT_SESSION_FILE,
+            )
+
+            status_file = Path(DEFAULT_OUTPUT_FILE)
+            session_file = Path(DEFAULT_SESSION_FILE)
+
+            def compute_server_side_values(status: dict) -> dict:
+                """Get elapsed_seconds and cost_usd from session tracker for persistence."""
+                # Get session data (persistent across refreshes)
+                session = get_session()
+
+                # Update session based on VM state if we have VM info
+                # IMPORTANT: Only pass vm_ip if it's truthy to avoid
+                # overwriting session's stable vm_ip with None
+                if status.get("vm_state") and status.get("vm_state") != "unknown":
+                    status_vm_ip = status.get("vm_ip")
+                    # Build update kwargs - only include vm_ip if present
+                    update_kwargs = {
+                        "vm_state": status["vm_state"],
+                        "vm_size": status.get("vm_size"),
+                    }
+                    if status_vm_ip:  # Only include if truthy
+                        update_kwargs["vm_ip"] = status_vm_ip
+                    session = update_session_vm_state(**update_kwargs)
+
+                # Use session's vm_ip as authoritative source
+                # This prevents IP flickering when status file has stale/None values
+                if session.get("vm_ip"):
+                    status["vm_ip"] = session["vm_ip"]
+
+                # Use session's elapsed_seconds and cost_usd for persistence
+                if (
+                    session.get("is_active")
+                    or session.get("accumulated_seconds", 0) > 0
+                ):
+                    status["elapsed_seconds"] = session.get("elapsed_seconds", 0.0)
+                    status["cost_usd"] = session.get("cost_usd", 0.0)
+                    status["started_at"] = session.get("started_at")
+                    status["session_id"] = session.get("session_id")
+                    status["session_is_active"] = session.get("is_active", False)
+                    # Include accumulated time from previous sessions for hybrid display
+                    status["accumulated_seconds"] = session.get(
+                        "accumulated_seconds", 0.0
+                    )
+                    # Calculate current session time (total - accumulated)
+                    current_session_seconds = max(
+                        0, status["elapsed_seconds"] - status["accumulated_seconds"]
+                    )
+                    status["current_session_seconds"] = current_session_seconds
+                    hourly_rate = session.get("hourly_rate_usd", 0.422)
+                    status["current_session_cost_usd"] = (
+                        current_session_seconds / 3600
+                    ) * hourly_rate
+
+                try:
+                    tunnel_mgr = get_tunnel_manager()
+                    tunnel_status = tunnel_mgr.get_tunnel_status()
+                    status["tunnels"] = {
+                        name: {
+                            "active": s.active,
+                            "local_port": s.local_port,
+                            "remote_endpoint": s.remote_endpoint,
+                            "pid": s.pid,
+                            "error": s.error,
+                        }
+                        for name, s in tunnel_status.items()
+                    }
+                except Exception as e:
+                    status["tunnels"] = {"error": str(e)}
+
+                return status
+
+            # Send initial connected event
+            if not send_event(
+                "connected",
+                {"timestamp": time.time(), "version": "1.0"},
+            ):
+                return
+
+            # Send initial status immediately
+            try:
+                status = compute_server_side_values(read_status())
+                if not send_event("status", status):
+                    return
+                if status_file.exists():
+                    last_mtime = status_file.stat().st_mtime
+            except Exception as e:
+                send_event("error", {"message": str(e)})
+
+            try:
+                iteration_count = 0
+                max_iterations = 3600  # Max 1 hour of streaming
+                last_status_send = 0.0
+                STATUS_SEND_INTERVAL = 2  # Send status every 2 seconds for live updates
+
+                while client_connected and iteration_count < max_iterations:
+                    iteration_count += 1
+                    current_time = time.time()
+
+                    # Check client connection
+                    if not check_client_connected():
+                        break
+
+                    # Send heartbeat every 30 seconds
+                    if current_time - last_heartbeat >= HEARTBEAT_INTERVAL:
+                        if not send_event("heartbeat", {"timestamp": current_time}):
+                            break
+                        last_heartbeat = current_time
+
+                    # Check if status or session file changed OR if enough time passed
+                    try:
+                        status_changed = False
+                        session_changed = False
+                        time_to_send = (
+                            current_time - last_status_send >= STATUS_SEND_INTERVAL
+                        )
+
+                        if status_file.exists():
+                            current_mtime = status_file.stat().st_mtime
+                            if current_mtime > last_mtime:
+                                status_changed = True
+                                last_mtime = current_mtime
+
+                        if session_file.exists():
+                            current_session_mtime = session_file.stat().st_mtime
+                            if current_session_mtime > last_session_mtime:
+                                session_changed = True
+                                last_session_mtime = current_session_mtime
+
+                        # Send status if file changed OR periodic timer expired
+                        # This ensures live elapsed time/cost updates even without file changes
+                        if status_changed or session_changed or time_to_send:
+                            # File changed or time to send - send update with session values
+                            status = compute_server_side_values(read_status())
+                            if not send_event("status", status):
+                                break
+                            last_status_send = current_time
+                    except Exception as e:
+                        # File access error - log but continue
+                        print(f"Azure ops SSE file check error: {e}")
+
+                    # Sleep briefly before next check
+                    try:
+                        select.select([self.rfile], [], [], CHECK_INTERVAL)
+                    except Exception:
+                        break
+
+            except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):
+                # Client disconnected - normal
+                pass
+            except Exception as e:
+                send_event("error", {"message": str(e)})
+            finally:
+                client_connected = False
+
+        def _detect_running_benchmark_sync(
+            self, vm_ip: str, container_name: str = "winarena"
+        ) -> dict:
             """Synchronous version of _detect_running_benchmark.
 
             Avoids creating a new event loop on each call which causes issues
@@ -1881,11 +3357,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
             try:
                 # Check if benchmark process is running
                 process_check = subprocess.run(
-                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                     "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                     f"azureuser@{vm_ip}",
-                     f"docker exec {container_name} pgrep -f 'python.*run.py' 2>/dev/null || echo ''"],
-                    capture_output=True, text=True, timeout=10
+                    [
+                        "ssh",
+                        "-o",
+                        "StrictHostKeyChecking=no",
+                        "-o",
+                        "ConnectTimeout=5",
+                        "-i",
+                        str(Path.home() / ".ssh" / "id_rsa"),
+                        f"azureuser@{vm_ip}",
+                        f"docker exec {container_name} pgrep -f 'python.*run.py' 2>/dev/null || echo ''",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
                 )
 
                 if process_check.returncode == 0 and process_check.stdout.strip():
@@ -1893,11 +3378,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
                     # Get benchmark log
                     log_check = subprocess.run(
-                        ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
-                         "-i", str(Path.home() / ".ssh" / "id_rsa"),
-                         f"azureuser@{vm_ip}",
-                         "tail -100 /tmp/waa_benchmark.log 2>/dev/null || echo ''"],
-                        capture_output=True, text=True, timeout=10
+                        [
+                            "ssh",
+                            "-o",
+                            "StrictHostKeyChecking=no",
+                            "-o",
+                            "ConnectTimeout=5",
+                            "-i",
+                            str(Path.home() / ".ssh" / "id_rsa"),
+                            f"azureuser@{vm_ip}",
+                            "tail -100 /tmp/waa_benchmark.log 2>/dev/null || echo ''",
+                        ],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
                     )
 
                     if log_check.returncode == 0 and log_check.stdout.strip():
@@ -1905,20 +3399,26 @@ def cmd_serve(args: argparse.Namespace) -> int:
                         result["recent_logs"] = logs[-500:]  # Last 500 chars
 
                         # Parse progress from logs
-                        task_match = re.search(r'Task\s+(\d+)/(\d+)', logs)
+                        task_match = re.search(r"Task\s+(\d+)/(\d+)", logs)
                         if task_match:
-                            result["progress"]["tasks_completed"] = int(task_match.group(1))
+                            result["progress"]["tasks_completed"] = int(
+                                task_match.group(1)
+                            )
                             result["progress"]["total_tasks"] = int(task_match.group(2))
 
                         # Extract current task ID
-                        task_id_match = re.search(r'(?:Running|Processing) task:\s*(\S+)', logs)
+                        task_id_match = re.search(
+                            r"(?:Running|Processing) task:\s*(\S+)", logs
+                        )
                         if task_id_match:
                             result["current_task"] = task_id_match.group(1)
 
                         # Extract step info
-                        step_match = re.search(r'Step\s+(\d+)', logs)
+                        step_match = re.search(r"Step\s+(\d+)", logs)
                         if step_match:
-                            result["progress"]["current_step"] = int(step_match.group(1))
+                            result["progress"]["current_step"] = int(
+                                step_match.group(1)
+                            )
 
             except Exception:
                 # SSH or parsing failed - leave defaults
@@ -1949,7 +3449,7 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 "vnc_port": vm_data.get("vnc_port", 8006),
                 "waa_port": vm_data.get("waa_port", 5000),
                 "docker_container": vm_data.get("docker_container", "win11-waa"),
-                "internal_ip": vm_data.get("internal_ip", "20.20.20.21")
+                "internal_ip": vm_data.get("internal_ip", "20.20.20.21"),
             }
 
             vms.append(new_vm)
@@ -1957,7 +3457,7 @@ def cmd_serve(args: argparse.Namespace) -> int:
             # Save registry
             try:
                 registry_file.parent.mkdir(parents=True, exist_ok=True)
-                with open(registry_file, 'w') as f:
+                with open(registry_file, "w") as f:
                     json.dump(vms, f, indent=2)
                 return {"status": "success", "vm": new_vm}
             except Exception as e:
@@ -1990,12 +3490,20 @@ def cmd_serve(args: argparse.Namespace) -> int:
 
             # Build CLI command
             cmd = [
-                "uv", "run", "python", "-m", "openadapt_ml.benchmarks.cli",
-                "vm", "run-waa",
-                "--num-tasks", str(params.get("num_tasks", 5)),
-                "--model", params.get("model", "gpt-4o"),
-                "--agent", params.get("agent", "navi"),
-                "--no-open"  # Don't open viewer (already open)
+                "uv",
+                "run",
+                "python",
+                "-m",
+                "openadapt_ml.benchmarks.cli",
+                "vm",
+                "run-waa",
+                "--num-tasks",
+                str(params.get("num_tasks", 5)),
+                "--model",
+                params.get("model", "gpt-4o"),
+                "--agent",
+                params.get("agent", "navi"),
+                "--no-open",  # Don't open viewer (already open)
             ]
 
             # Add task selection args
@@ -2016,7 +3524,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
             num_tasks = params.get("num_tasks", 5)
             agent = params.get("agent", "navi")
 
-            print(f"\n[Benchmark] Starting WAA benchmark: model={model}, tasks={num_tasks}, agent={agent}")
+            print(
+                f"\n[Benchmark] Starting WAA benchmark: model={model}, tasks={num_tasks}, agent={agent}"
+            )
             print(f"[Benchmark] Task selection: {task_selection}")
             if task_selection == "domain":
                 print(f"[Benchmark] Domain: {params.get('domain', 'general')}")
@@ -2024,15 +3534,19 @@ def cmd_serve(args: argparse.Namespace) -> int:
                 print(f"[Benchmark] Task IDs: {params.get('task_ids', [])}")
             print(f"[Benchmark] Command: {' '.join(cmd)}")
 
-            progress_file.write_text(json.dumps({
-                "status": "running",
-                "model": model,
-                "num_tasks": num_tasks,
-                "agent": agent,
-                "task_selection": task_selection,
-                "tasks_complete": 0,
-                "message": f"Starting {model} benchmark with {num_tasks} tasks..."
-            }))
+            progress_file.write_text(
+                json.dumps(
+                    {
+                        "status": "running",
+                        "model": model,
+                        "num_tasks": num_tasks,
+                        "agent": agent,
+                        "task_selection": task_selection,
+                        "tasks_complete": 0,
+                        "message": f"Starting {model} benchmark with {num_tasks} tasks...",
+                    }
+                )
+            )
 
             # Copy environment with loaded vars
             env = os.environ.copy()
@@ -2040,11 +3554,7 @@ def cmd_serve(args: argparse.Namespace) -> int:
             # Run in background thread
             def run():
                 result = subprocess.run(
-                    cmd,
-                    capture_output=True,
-                    text=True,
-                    cwd=str(project_root),
-                    env=env
+                    cmd, capture_output=True, text=True, cwd=str(project_root), env=env
                 )
 
                 print(f"\n[Benchmark] Output:\n{result.stdout}")
@@ -2052,24 +3562,34 @@ def cmd_serve(args: argparse.Namespace) -> int:
                     print(f"[Benchmark] Stderr: {result.stderr}")
 
                 if result.returncode == 0:
-                    print(f"[Benchmark] Complete. Regenerating viewer...")
-                    progress_file.write_text(json.dumps({
-                        "status": "complete",
-                        "model": model,
-                        "num_tasks": num_tasks,
-                        "message": "Benchmark complete. Refresh to see results."
-                    }))
+                    print("[Benchmark] Complete. Regenerating viewer...")
+                    progress_file.write_text(
+                        json.dumps(
+                            {
+                                "status": "complete",
+                                "model": model,
+                                "num_tasks": num_tasks,
+                                "message": "Benchmark complete. Refresh to see results.",
+                            }
+                        )
+                    )
                     # Regenerate benchmark viewer
                     _regenerate_benchmark_viewer_if_available(serve_dir)
                 else:
-                    error_msg = result.stderr[:200] if result.stderr else "Unknown error"
+                    error_msg = (
+                        result.stderr[:200] if result.stderr else "Unknown error"
+                    )
                     print(f"[Benchmark] Failed: {error_msg}")
-                    progress_file.write_text(json.dumps({
-                        "status": "error",
-                        "model": model,
-                        "num_tasks": num_tasks,
-                        "message": f"Benchmark failed: {error_msg}"
-                    }))
+                    progress_file.write_text(
+                        json.dumps(
+                            {
+                                "status": "error",
+                                "model": model,
+                                "num_tasks": num_tasks,
+                                "message": f"Benchmark failed: {error_msg}",
+                            }
+                        )
+                    )
 
             threading.Thread(target=run, daemon=True).start()
 
@@ -2078,9 +3598,9 @@ def cmd_serve(args: argparse.Namespace) -> int:
         def do_OPTIONS(self):
             # Handle CORS preflight
             self.send_response(200)
-            self.send_header('Access-Control-Allow-Origin', '*')
-            self.send_header('Access-Control-Allow-Methods', 'POST, OPTIONS')
-            self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Methods", "POST, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
             self.end_headers()
 
     class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
@@ -2134,7 +3654,9 @@ def cmd_viewer(args: argparse.Namespace) -> int:
         state.learning_rate = data.get("learning_rate", 0)
         state.losses = data.get("losses", [])
         state.status = data.get("status", "completed")
-        state.elapsed_time = data.get("elapsed_time", 0.0)  # Load elapsed time for completed training
+        state.elapsed_time = data.get(
+            "elapsed_time", 0.0
+        )  # Load elapsed time for completed training
         state.goal = data.get("goal", "")
         state.config_path = data.get("config_path", "")
         state.capture_path = data.get("capture_path", "")
@@ -2149,6 +3671,7 @@ def cmd_viewer(args: argparse.Namespace) -> int:
         if not state.model_name and state.config_path:
             try:
                 import yaml
+
                 # Try relative to project root first, then as absolute path
                 project_root = Path(__file__).parent.parent.parent
                 config_file = project_root / state.config_path
@@ -2173,14 +3696,16 @@ def cmd_viewer(args: argparse.Namespace) -> int:
 
         dashboard_html = generate_training_dashboard(state, config)
         (current_dir / "dashboard.html").write_text(dashboard_html)
-        print(f"  Regenerated: dashboard.html")
+        print("  Regenerated: dashboard.html")
 
     # Generate unified viewer using consolidated function
     viewer_path = generate_unified_viewer_from_output_dir(current_dir)
     if viewer_path:
         print(f"\nGenerated: {viewer_path}")
     else:
-        print("\nNo comparison data found. Run comparison first or copy from capture directory.")
+        print(
+            "\nNo comparison data found. Run comparison first or copy from capture directory."
+        )
 
     # Also regenerate benchmark viewer from latest benchmark results
     _regenerate_benchmark_viewer_if_available(current_dir)
@@ -2200,9 +3725,9 @@ def cmd_benchmark_viewer(args: argparse.Namespace) -> int:
         print(f"Error: Benchmark directory not found: {benchmark_dir}")
         return 1
 
-    print(f"\n{'='*50}")
+    print(f"\n{'=' * 50}")
     print("GENERATING BENCHMARK VIEWER")
-    print(f"{'='*50}")
+    print(f"{'=' * 50}")
     print(f"Benchmark dir: {benchmark_dir}")
     print()
 
@@ -2217,6 +3742,7 @@ def cmd_benchmark_viewer(args: argparse.Namespace) -> int:
     except Exception as e:
         print(f"Error generating benchmark viewer: {e}")
         import traceback
+
         traceback.print_exc()
         return 1
 
@@ -2233,16 +3759,19 @@ def cmd_compare(args: argparse.Namespace) -> int:
         print(f"Error: Checkpoint not found: {checkpoint}")
         return 1
 
-    print(f"\n{'='*50}")
+    print(f"\n{'=' * 50}")
     print("RUNNING COMPARISON")
-    print(f"{'='*50}")
+    print(f"{'=' * 50}")
     print(f"Capture: {capture_path}")
     print(f"Checkpoint: {checkpoint or 'None (capture only)'}")
     print()
 
     cmd = [
-        sys.executable, "-m", "openadapt_ml.scripts.compare",
-        "--capture", str(capture_path),
+        sys.executable,
+        "-m",
+        "openadapt_ml.scripts.compare",
+        "--capture",
+        str(capture_path),
     ]
 
     if checkpoint:
@@ -2281,7 +3810,7 @@ Examples:
 
   # Run comparison
   uv run python -m openadapt_ml.cloud.local compare --capture ~/captures/my-workflow --checkpoint checkpoints/model
-"""
+""",
     )
 
     subparsers = parser.add_subparsers(dest="command", help="Command")
@@ -2293,9 +3822,15 @@ Examples:
     # train
     p_train = subparsers.add_parser("train", help="Run training locally")
     p_train.add_argument("--capture", required=True, help="Path to capture directory")
-    p_train.add_argument("--goal", help="Task goal (default: derived from capture name)")
-    p_train.add_argument("--config", help="Config file (default: auto-select based on device)")
-    p_train.add_argument("--open", action="store_true", help="Open dashboard in browser")
+    p_train.add_argument(
+        "--goal", help="Task goal (default: derived from capture name)"
+    )
+    p_train.add_argument(
+        "--config", help="Config file (default: auto-select based on device)"
+    )
+    p_train.add_argument(
+        "--open", action="store_true", help="Open dashboard in browser"
+    )
     p_train.set_defaults(func=cmd_train)
 
     # check
@@ -2306,11 +3841,21 @@ Examples:
     p_serve = subparsers.add_parser("serve", help="Start web server for dashboard")
     p_serve.add_argument("--port", type=int, default=8765, help="Port number")
     p_serve.add_argument("--open", action="store_true", help="Open in browser")
-    p_serve.add_argument("--quiet", "-q", action="store_true", help="Suppress request logging")
-    p_serve.add_argument("--no-regenerate", action="store_true",
-                         help="Skip regenerating dashboard/viewer (serve existing files)")
-    p_serve.add_argument("--benchmark", help="Serve benchmark results directory instead of training output")
-    p_serve.add_argument("--start-page", help="Override default start page (e.g., benchmark.html)")
+    p_serve.add_argument(
+        "--quiet", "-q", action="store_true", help="Suppress request logging"
+    )
+    p_serve.add_argument(
+        "--no-regenerate",
+        action="store_true",
+        help="Skip regenerating dashboard/viewer (serve existing files)",
+    )
+    p_serve.add_argument(
+        "--benchmark",
+        help="Serve benchmark results directory instead of training output",
+    )
+    p_serve.add_argument(
+        "--start-page", help="Override default start page (e.g., benchmark.html)"
+    )
     p_serve.set_defaults(func=cmd_serve)
 
     # viewer
@@ -2319,9 +3864,15 @@ Examples:
     p_viewer.set_defaults(func=cmd_viewer)
 
     # benchmark_viewer
-    p_benchmark = subparsers.add_parser("benchmark-viewer", help="Generate benchmark viewer")
-    p_benchmark.add_argument("benchmark_dir", help="Path to benchmark results directory")
-    p_benchmark.add_argument("--open", action="store_true", help="Open viewer in browser")
+    p_benchmark = subparsers.add_parser(
+        "benchmark-viewer", help="Generate benchmark viewer"
+    )
+    p_benchmark.add_argument(
+        "benchmark_dir", help="Path to benchmark results directory"
+    )
+    p_benchmark.add_argument(
+        "--open", action="store_true", help="Open viewer in browser"
+    )
     p_benchmark.set_defaults(func=cmd_benchmark_viewer)
 
     # compare