Add SFT warm start training pipeline

results/training_dashboard.json

@@ -1,6 +1,6 @@
 {
-  "status": "eval_completed",
-  "updated_at": "2026-04-26 10:53 IST",
+  "status": "pipeline_upgraded",
+  "updated_at": "2026-04-26 11:10 IST",
   "hardware": "a10g-small",
   "summary": "30-step smoke training completed and pushed adapters. Eval did not show improvement yet; this validates the pipeline but not learning progress.",
   "runs": [
@@ -74,5 +74,1881 @@
       "invalid_payloads": 1,
       "invalid_actions": 0
     }
-  ]
+  ],
+  "training_series": {
+    "center": {
+      "source_log": "results\\center_train_job.log",
+      "steps": [
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 1e-06,
+          "num_tokens": 3082.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 1.627,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 15.12,
+          "epoch": 0.02778,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 1
+        },
+        {
+          "loss": 0.4278,
+          "grad_norm": 1.68,
+          "learning_rate": 9.667e-07,
+          "num_tokens": 5533.0,
+          "completions/mean_length": 159.5,
+          "completions/min_length": 63.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 63.0,
+          "completions/min_terminated_length": 63.0,
+          "completions/max_terminated_length": 63.0,
+          "rewards/reward_completions/mean": -3.014,
+          "rewards/reward_completions/std": 7.051,
+          "reward": -3.014,
+          "reward_std": 7.051,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 1.15,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.61,
+          "epoch": 0.05556,
+          "completion_length": 159.5,
+          "clipped_ratio": 0.5,
+          "step": 2
+        },
+        {
+          "loss": 0.09386,
+          "grad_norm": 1.048,
+          "learning_rate": 9.333e-07,
+          "num_tokens": 8641.0,
+          "completions/mean_length": 226.0,
+          "completions/min_length": 196.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 196.0,
+          "completions/min_terminated_length": 196.0,
+          "completions/max_terminated_length": 196.0,
+          "rewards/reward_completions/mean": -1.928,
+          "rewards/reward_completions/std": 8.587,
+          "reward": -1.928,
+          "reward_std": 8.587,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.7438,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.57,
+          "epoch": 0.08333,
+          "completion_length": 226.0,
+          "clipped_ratio": 0.5,
+          "step": 3
+        },
+        {
+          "loss": 0.01842,
+          "grad_norm": 0.858,
+          "learning_rate": 9e-07,
+          "num_tokens": 11720.0,
+          "completions/mean_length": 249.5,
+          "completions/min_length": 243.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 243.0,
+          "completions/min_terminated_length": 243.0,
+          "completions/max_terminated_length": 243.0,
+          "rewards/reward_completions/mean": -2.648,
+          "rewards/reward_completions/std": 7.569,
+          "reward": -2.648,
+          "reward_std": 7.569,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.2652,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.57,
+          "epoch": 0.1111,
+          "completion_length": 249.5,
+          "clipped_ratio": 0.5,
+          "step": 4
+        },
+        {
+          "loss": 0.3577,
+          "grad_norm": 1.185,
+          "learning_rate": 8.667e-07,
+          "num_tokens": 14150.0,
+          "completions/mean_length": 170.0,
+          "completions/min_length": 84.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 84.0,
+          "completions/min_terminated_length": 84.0,
+          "completions/max_terminated_length": 84.0,
+          "rewards/reward_completions/mean": -3.044,
+          "rewards/reward_completions/std": 7.009,
+          "reward": -3.044,
+          "reward_std": 7.009,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.755,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.5,
+          "epoch": 0.1389,
+          "completion_length": 170.0,
+          "clipped_ratio": 0.5,
+          "step": 5
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 8.333e-07,
+          "num_tokens": 16970.0,
+          "completions/mean_length": 177.0,
+          "completions/min_length": 131.0,
+          "completions/max_length": 223.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 177.0,
+          "completions/min_terminated_length": 131.0,
+          "completions/max_terminated_length": 223.0,
+          "rewards/reward_completions/mean": 0.5122,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 0.5122,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 1.003,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 12.66,
+          "epoch": 0.1667,
+          "completion_length": 177.0,
+          "clipped_ratio": 0.0,
+          "step": 6
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 8e-07,
+          "num_tokens": 20100.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.2946,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.51,
+          "epoch": 0.1944,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 7
+        },
+        {
+          "loss": 0.3392,
+          "grad_norm": 1.515,
+          "learning_rate": 7.667e-07,
+          "num_tokens": 22980.0,
+          "completions/mean_length": 173.0,
+          "completions/min_length": 90.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 90.0,
+          "completions/min_terminated_length": 90.0,
+          "completions/max_terminated_length": 90.0,
+          "rewards/reward_completions/mean": -2.942,
+          "rewards/reward_completions/std": 7.153,
+          "reward": -2.942,
+          "reward_std": 7.153,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.8725,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.57,
+          "epoch": 0.2222,
+          "completion_length": 173.0,
+          "clipped_ratio": 0.5,
+          "step": 8
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 7.333e-07,
+          "num_tokens": 25860.0,
+          "completions/mean_length": 200.5,
+          "completions/min_length": 200.0,
+          "completions/max_length": 201.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 200.5,
+          "completions/min_terminated_length": 200.0,
+          "completions/max_terminated_length": 201.0,
+          "rewards/reward_completions/mean": 2.848,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 2.848,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.9884,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 11.6,
+          "epoch": 0.25,
+          "completion_length": 200.5,
+          "clipped_ratio": 0.0,
+          "step": 9
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 7e-07,
+          "num_tokens": 28890.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.06355,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.68,
+          "epoch": 0.2778,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 10
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 6.667e-07,
+          "num_tokens": 31890.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.4979,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.65,
+          "epoch": 0.3056,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 11
+        },
+        {
+          "loss": 0.09564,
+          "grad_norm": 0.9437,
+          "learning_rate": 6.333e-07,
+          "num_tokens": 34460.0,
+          "completions/mean_length": 225.5,
+          "completions/min_length": 195.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 195.0,
+          "completions/min_terminated_length": 195.0,
+          "completions/max_terminated_length": 195.0,
+          "rewards/reward_completions/mean": -3.376,
+          "rewards/reward_completions/std": 6.539,
+          "reward": -3.376,
+          "reward_std": 6.539,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.5531,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.52,
+          "epoch": 0.3333,
+          "completion_length": 225.5,
+          "clipped_ratio": 0.5,
+          "step": 12
+        },
+        {
+          "loss": 0.4957,
+          "grad_norm": 1.425,
+          "learning_rate": 6e-07,
+          "num_tokens": 37220.0,
+          "completions/mean_length": 150.5,
+          "completions/min_length": 45.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 45.0,
+          "completions/min_terminated_length": 45.0,
+          "completions/max_terminated_length": 45.0,
+          "rewards/reward_completions/mean": -2.778,
+          "rewards/reward_completions/std": 7.385,
+          "reward": -2.778,
+          "reward_std": 7.385,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.8273,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.7,
+          "epoch": 0.3611,
+          "completion_length": 150.5,
+          "clipped_ratio": 0.5,
+          "step": 13
+        },
+        {
+          "loss": 0.07147,
+          "grad_norm": 1.156,
+          "learning_rate": 5.667e-07,
+          "num_tokens": 40280.0,
+          "completions/mean_length": 232.5,
+          "completions/min_length": 209.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 209.0,
+          "completions/min_terminated_length": 209.0,
+          "completions/max_terminated_length": 209.0,
+          "rewards/reward_completions/mean": -3.959,
+          "rewards/reward_completions/std": 5.715,
+          "reward": -3.959,
+          "reward_std": 5.715,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.7875,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.51,
+          "epoch": 0.3889,
+          "completion_length": 232.5,
+          "clipped_ratio": 0.5,
+          "step": 14
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 5.333e-07,
+          "num_tokens": 42900.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.06475,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.5,
+          "epoch": 0.4167,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 15
+        },
+        {
+          "loss": 0.101,
+          "grad_norm": 0.9229,
+          "learning_rate": 5e-07,
+          "num_tokens": 46060.0,
+          "completions/mean_length": 224.0,
+          "completions/min_length": 192.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 192.0,
+          "completions/min_terminated_length": 192.0,
+          "completions/max_terminated_length": 192.0,
+          "rewards/reward_completions/mean": -3.372,
+          "rewards/reward_completions/std": 6.545,
+          "reward": -3.372,
+          "reward_std": 6.545,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.5082,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.68,
+          "epoch": 0.4444,
+          "completion_length": 224.0,
+          "clipped_ratio": 0.5,
+          "step": 16
+        },
+        {
+          "loss": 0.07823,
+          "grad_norm": 1.086,
+          "learning_rate": 4.667e-07,
+          "num_tokens": 48650.0,
+          "completions/mean_length": 230.5,
+          "completions/min_length": 205.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 205.0,
+          "completions/min_terminated_length": 205.0,
+          "completions/max_terminated_length": 205.0,
+          "rewards/reward_completions/mean": -1.764,
+          "rewards/reward_completions/std": 8.819,
+          "reward": -1.764,
+          "reward_std": 8.819,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.8177,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.56,
+          "epoch": 0.4722,
+          "completion_length": 230.5,
+          "clipped_ratio": 0.5,
+          "step": 17
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 4.333e-07,
+          "num_tokens": 51320.0,
+          "completions/mean_length": 78.5,
+          "completions/min_length": 74.0,
+          "completions/max_length": 83.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 78.5,
+          "completions/min_terminated_length": 74.0,
+          "completions/max_terminated_length": 83.0,
+          "rewards/reward_completions/mean": 2.844,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 2.844,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 1.933,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 5.248,
+          "epoch": 0.5,
+          "completion_length": 78.5,
+          "clipped_ratio": 0.0,
+          "step": 18
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 4e-07,
+          "num_tokens": 54290.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.0686,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.69,
+          "epoch": 0.5278,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 19
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 3.667e-07,
+          "num_tokens": 57200.0,
+          "completions/mean_length": 183.5,
+          "completions/min_length": 150.0,
+          "completions/max_length": 217.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 183.5,
+          "completions/min_terminated_length": 150.0,
+          "completions/max_terminated_length": 217.0,
+          "rewards/reward_completions/mean": 2.672,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 2.672,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.8566,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 12.47,
+          "epoch": 0.5556,
+          "completion_length": 183.5,
+          "clipped_ratio": 0.0,
+          "step": 20
+        },
+        {
+          "loss": 0.06483,
+          "grad_norm": 1.153,
+          "learning_rate": 3.333e-07,
+          "num_tokens": 60320.0,
+          "completions/mean_length": 234.5,
+          "completions/min_length": 213.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 213.0,
+          "completions/min_terminated_length": 213.0,
+          "completions/max_terminated_length": 213.0,
+          "rewards/reward_completions/mean": -3.488,
+          "rewards/reward_completions/std": 6.381,
+          "reward": -3.488,
+          "reward_std": 6.381,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.6029,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.57,
+          "epoch": 0.5833,
+          "completion_length": 234.5,
+          "clipped_ratio": 0.5,
+          "step": 21
+        },
+        {
+          "loss": 0.6747,
+          "grad_norm": 1.753,
+          "learning_rate": 3e-07,
+          "num_tokens": 63170.0,
+          "completions/mean_length": 131.0,
+          "completions/min_length": 6.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 6.0,
+          "completions/min_terminated_length": 6.0,
+          "completions/max_terminated_length": 6.0,
+          "rewards/reward_completions/mean": -3.338,
+          "rewards/reward_completions/std": 6.593,
+          "reward": -3.338,
+          "reward_std": 6.593,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.4945,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.57,
+          "epoch": 0.6111,
+          "completion_length": 131.0,
+          "clipped_ratio": 0.5,
+          "step": 22
+        },
+        {
+          "loss": 0.5278,
+          "grad_norm": 1.556,
+          "learning_rate": 2.667e-07,
+          "num_tokens": 66020.0,
+          "completions/mean_length": 138.0,
+          "completions/min_length": 35.0,
+          "completions/max_length": 241.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 138.0,
+          "completions/min_terminated_length": 35.0,
+          "completions/max_terminated_length": 241.0,
+          "rewards/reward_completions/mean": -2.936,
+          "rewards/reward_completions/std": 7.162,
+          "reward": -2.936,
+          "reward_std": 7.162,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 1.108,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 13.85,
+          "epoch": 0.6389,
+          "completion_length": 138.0,
+          "clipped_ratio": 0.0,
+          "step": 23
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 2.333e-07,
+          "num_tokens": 68630.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.102,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.58,
+          "epoch": 0.6667,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 24
+        },
+        {
+          "loss": 0.2583,
+          "grad_norm": 1.3,
+          "learning_rate": 2e-07,
+          "num_tokens": 71160.0,
+          "completions/mean_length": 187.5,
+          "completions/min_length": 119.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 119.0,
+          "completions/min_terminated_length": 119.0,
+          "completions/max_terminated_length": 119.0,
+          "rewards/reward_completions/mean": -3.544,
+          "rewards/reward_completions/std": 6.302,
+          "reward": -3.544,
+          "reward_std": 6.302,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.9402,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.71,
+          "epoch": 0.6944,
+          "completion_length": 187.5,
+          "clipped_ratio": 0.5,
+          "step": 25
+        },
+        {
+          "loss": 0.4722,
+          "grad_norm": 1.068,
+          "learning_rate": 1.667e-07,
+          "num_tokens": 73970.0,
+          "completions/mean_length": 153.5,
+          "completions/min_length": 51.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 51.0,
+          "completions/min_terminated_length": 51.0,
+          "completions/max_terminated_length": 51.0,
+          "rewards/reward_completions/mean": -3.54,
+          "rewards/reward_completions/std": 6.307,
+          "reward": -3.54,
+          "reward_std": 6.307,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.9242,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.58,
+          "epoch": 0.7222,
+          "completion_length": 153.5,
+          "clipped_ratio": 0.5,
+          "step": 26
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 1.333e-07,
+          "num_tokens": 76560.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.9256,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.47,
+          "epoch": 0.75,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 27
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 1e-07,
+          "num_tokens": 79250.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.6306,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.61,
+          "epoch": 0.7778,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 28
+        },
+        {
+          "loss": 0.3016,
+          "grad_norm": 1.609,
+          "learning_rate": 6.667e-08,
+          "num_tokens": 82100.0,
+          "completions/mean_length": 139.5,
+          "completions/min_length": 80.0,
+          "completions/max_length": 199.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 139.5,
+          "completions/min_terminated_length": 80.0,
+          "completions/max_terminated_length": 199.0,
+          "rewards/reward_completions/mean": -3.454,
+          "rewards/reward_completions/std": 6.429,
+          "reward": -3.454,
+          "reward_std": 6.429,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 1.362,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 11.6,
+          "epoch": 0.8056,
+          "completion_length": 139.5,
+          "clipped_ratio": 0.0,
+          "step": 29
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 3.333e-08,
+          "num_tokens": 84690.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.04163,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.61,
+          "epoch": 0.8333,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 30
+        }
+      ],
+      "reward_batches": [
+        {
+          "call": 1,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 2,
+          "max_reward": -8.0,
+          "mean_reward": -8.0,
+          "message": "reward_batch",
+          "min_reward": -8.0,
+          "role": "center"
+        },
+        {
+          "call": 10,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 2,
+          "max_reward": -8.0,
+          "mean_reward": -8.0,
+          "message": "reward_batch",
+          "min_reward": -8.0,
+          "role": "center"
+        },
+        {
+          "call": 20,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 0,
+          "max_reward": 2.672,
+          "mean_reward": 2.672,
+          "message": "reward_batch",
+          "min_reward": 2.672,
+          "role": "center"
+        },
+        {
+          "call": 30,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 2,
+          "max_reward": -8.0,
+          "mean_reward": -8.0,
+          "message": "reward_batch",
+          "min_reward": -8.0,
+          "role": "center"
+        }
+      ]
+    },
+    "warehouse": {
+      "source_log": "results\\warehouse_train_job.log",
+      "steps": [
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 1e-06,
+          "num_tokens": 4050.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.4094,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 15.48,
+          "epoch": 0.02778,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 1
+        },
+        {
+          "loss": 0.3127,
+          "grad_norm": 1.122,
+          "learning_rate": 9.667e-07,
+          "num_tokens": 6999.0,
+          "completions/mean_length": 177.5,
+          "completions/min_length": 99.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 99.0,
+          "completions/min_terminated_length": 99.0,
+          "completions/max_terminated_length": 99.0,
+          "rewards/reward_completions/mean": -3.53,
+          "rewards/reward_completions/std": 6.322,
+          "reward": -3.53,
+          "reward_std": 6.322,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.4915,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.84,
+          "epoch": 0.05556,
+          "completion_length": 177.5,
+          "clipped_ratio": 0.5,
+          "step": 2
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 9.333e-07,
+          "num_tokens": 11900.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.2992,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 15.08,
+          "epoch": 0.08333,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 3
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 9e-07,
+          "num_tokens": 14640.0,
+          "completions/mean_length": 97.0,
+          "completions/min_length": 32.0,
+          "completions/max_length": 162.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 97.0,
+          "completions/min_terminated_length": 32.0,
+          "completions/max_terminated_length": 162.0,
+          "rewards/reward_completions/mean": 0.8633,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 0.8633,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 1.096,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 9.737,
+          "epoch": 0.1111,
+          "completion_length": 97.0,
+          "clipped_ratio": 0.0,
+          "step": 4
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 8.667e-07,
+          "num_tokens": 17530.0,
+          "completions/mean_length": 171.0,
+          "completions/min_length": 86.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 86.0,
+          "completions/min_terminated_length": 86.0,
+          "completions/max_terminated_length": 86.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.2295,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.84,
+          "epoch": 0.1389,
+          "completion_length": 171.0,
+          "clipped_ratio": 0.5,
+          "step": 5
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 8.333e-07,
+          "num_tokens": 20420.0,
+          "completions/mean_length": 221.5,
+          "completions/min_length": 187.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 187.0,
+          "completions/min_terminated_length": 187.0,
+          "completions/max_terminated_length": 187.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.3646,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.81,
+          "epoch": 0.1667,
+          "completion_length": 221.5,
+          "clipped_ratio": 0.5,
+          "step": 6
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 8e-07,
+          "num_tokens": 24280.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.2839,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.82,
+          "epoch": 0.1944,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 7
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 7.667e-07,
+          "num_tokens": 27330.0,
+          "completions/mean_length": 21.5,
+          "completions/min_length": 19.0,
+          "completions/max_length": 24.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 21.5,
+          "completions/min_terminated_length": 19.0,
+          "completions/max_terminated_length": 24.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 1.141,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 2.069,
+          "epoch": 0.2222,
+          "completion_length": 21.5,
+          "clipped_ratio": 0.0,
+          "step": 8
+        },
+        {
+          "loss": 0.2284,
+          "grad_norm": 1.003,
+          "learning_rate": 7.333e-07,
+          "num_tokens": 30430.0,
+          "completions/mean_length": 193.5,
+          "completions/min_length": 131.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 131.0,
+          "completions/min_terminated_length": 131.0,
+          "completions/max_terminated_length": 131.0,
+          "rewards/reward_completions/mean": -3.516,
+          "rewards/reward_completions/std": 6.342,
+          "reward": -3.516,
+          "reward_std": 6.342,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.4621,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.85,
+          "epoch": 0.25,
+          "completion_length": 193.5,
+          "clipped_ratio": 0.5,
+          "step": 9
+        },
+        {
+          "loss": -0.3379,
+          "grad_norm": 1.762,
+          "learning_rate": 7e-07,
+          "num_tokens": 33690.0,
+          "completions/mean_length": 124.5,
+          "completions/min_length": 65.0,
+          "completions/max_length": 184.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 124.5,
+          "completions/min_terminated_length": 65.0,
+          "completions/max_terminated_length": 184.0,
+          "rewards/reward_completions/mean": -4.32,
+          "rewards/reward_completions/std": 5.205,
+          "reward": -4.32,
+          "reward_std": 5.205,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.4933,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 10.8,
+          "epoch": 0.2778,
+          "completion_length": 124.5,
+          "clipped_ratio": 0.0,
+          "step": 10
+        },
+        {
+          "loss": 0.09742,
+          "grad_norm": 0.6973,
+          "learning_rate": 6.667e-07,
+          "num_tokens": 36580.0,
+          "completions/mean_length": 225.0,
+          "completions/min_length": 194.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 194.0,
+          "completions/min_terminated_length": 194.0,
+          "completions/max_terminated_length": 194.0,
+          "rewards/reward_completions/mean": -4.728,
+          "rewards/reward_completions/std": 4.628,
+          "reward": -4.728,
+          "reward_std": 4.628,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.3318,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.69,
+          "epoch": 0.3056,
+          "completion_length": 225.0,
+          "clipped_ratio": 0.5,
+          "step": 11
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 6.333e-07,
+          "num_tokens": 39430.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.5381,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.71,
+          "epoch": 0.3333,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 12
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 6e-07,
+          "num_tokens": 42910.0,
+          "completions/mean_length": 140.5,
+          "completions/min_length": 140.0,
+          "completions/max_length": 141.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 140.5,
+          "completions/min_terminated_length": 140.0,
+          "completions/max_terminated_length": 141.0,
+          "rewards/reward_completions/mean": 0.51,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 0.51,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.4382,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 8.593,
+          "epoch": 0.3611,
+          "completion_length": 140.5,
+          "clipped_ratio": 0.0,
+          "step": 13
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 5.667e-07,
+          "num_tokens": 46500.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.3101,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.95,
+          "epoch": 0.3889,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 14
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 5.333e-07,
+          "num_tokens": 49590.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.06061,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.74,
+          "epoch": 0.4167,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 15
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 5e-07,
+          "num_tokens": 53260.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.4906,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.9,
+          "epoch": 0.4444,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 16
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 4.667e-07,
+          "num_tokens": 56880.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.1981,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.74,
+          "epoch": 0.4722,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 17
+        },
+        {
+          "loss": 0.6388,
+          "grad_norm": 1.889,
+          "learning_rate": 4.333e-07,
+          "num_tokens": 60150.0,
+          "completions/mean_length": 134.5,
+          "completions/min_length": 13.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 13.0,
+          "completions/min_terminated_length": 13.0,
+          "completions/max_terminated_length": 13.0,
+          "rewards/reward_completions/mean": -3.513,
+          "rewards/reward_completions/std": 6.346,
+          "reward": -3.513,
+          "reward_std": 6.346,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.5667,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.92,
+          "epoch": 0.5,
+          "completion_length": 134.5,
+          "clipped_ratio": 0.5,
+          "step": 18
+        },
+        {
+          "loss": 0.5243,
+          "grad_norm": 1.268,
+          "learning_rate": 4e-07,
+          "num_tokens": 62860.0,
+          "completions/mean_length": 147.0,
+          "completions/min_length": 38.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 38.0,
+          "completions/min_terminated_length": 38.0,
+          "completions/max_terminated_length": 38.0,
+          "rewards/reward_completions/mean": -3.716,
+          "rewards/reward_completions/std": 6.059,
+          "reward": -3.716,
+          "reward_std": 6.059,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.8373,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.79,
+          "epoch": 0.5278,
+          "completion_length": 147.0,
+          "clipped_ratio": 0.5,
+          "step": 19
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 3.667e-07,
+          "num_tokens": 65780.0,
+          "completions/mean_length": 77.0,
+          "completions/min_length": 64.0,
+          "completions/max_length": 90.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 77.0,
+          "completions/min_terminated_length": 64.0,
+          "completions/max_terminated_length": 90.0,
+          "rewards/reward_completions/mean": 0.932,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 0.932,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.7881,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 5.699,
+          "epoch": 0.5556,
+          "completion_length": 77.0,
+          "clipped_ratio": 0.0,
+          "step": 20
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 3.333e-07,
+          "num_tokens": 70160.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.5528,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.82,
+          "epoch": 0.5833,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 21
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 3e-07,
+          "num_tokens": 73480.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.3867,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.77,
+          "epoch": 0.6111,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 22
+        },
+        {
+          "loss": 0.2431,
+          "grad_norm": 1.327,
+          "learning_rate": 2.667e-07,
+          "num_tokens": 76920.0,
+          "completions/mean_length": 190.5,
+          "completions/min_length": 125.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 125.0,
+          "completions/min_terminated_length": 125.0,
+          "completions/max_terminated_length": 125.0,
+          "rewards/reward_completions/mean": -3.758,
+          "rewards/reward_completions/std": 5.999,
+          "reward": -3.758,
+          "reward_std": 5.999,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.6645,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.8,
+          "epoch": 0.6389,
+          "completion_length": 190.5,
+          "clipped_ratio": 0.5,
+          "step": 23
+        },
+        {
+          "loss": 0.04159,
+          "grad_norm": 5.867,
+          "learning_rate": 2.333e-07,
+          "num_tokens": 79280.0,
+          "completions/mean_length": 25.5,
+          "completions/min_length": 24.0,
+          "completions/max_length": 27.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 25.5,
+          "completions/min_terminated_length": 24.0,
+          "completions/max_terminated_length": 27.0,
+          "rewards/reward_completions/mean": -3.545,
+          "rewards/reward_completions/std": 6.3,
+          "reward": -3.545,
+          "reward_std": 6.3,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 1.493,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 2.284,
+          "epoch": 0.6667,
+          "completion_length": 25.5,
+          "clipped_ratio": 0.0,
+          "step": 24
+        },
+        {
+          "loss": 0.5813,
+          "grad_norm": 1.224,
+          "learning_rate": 2e-07,
+          "num_tokens": 81420.0,
+          "completions/mean_length": 140.5,
+          "completions/min_length": 25.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 25.0,
+          "completions/min_terminated_length": 25.0,
+          "completions/max_terminated_length": 25.0,
+          "rewards/reward_completions/mean": -3.538,
+          "rewards/reward_completions/std": 6.31,
+          "reward": -3.538,
+          "reward_std": 6.31,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.5115,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.88,
+          "epoch": 0.6944,
+          "completion_length": 140.5,
+          "clipped_ratio": 0.5,
+          "step": 25
+        },
+        {
+          "loss": 0.5813,
+          "grad_norm": 1.274,
+          "learning_rate": 1.667e-07,
+          "num_tokens": 84420.0,
+          "completions/mean_length": 140.5,
+          "completions/min_length": 25.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 25.0,
+          "completions/min_terminated_length": 25.0,
+          "completions/max_terminated_length": 25.0,
+          "rewards/reward_completions/mean": -3.514,
+          "rewards/reward_completions/std": 6.344,
+          "reward": -3.514,
+          "reward_std": 6.344,
+          "frac_reward_zero_std": 0.0,
+          "entropy": 0.5967,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.89,
+          "epoch": 0.7222,
+          "completion_length": 140.5,
+          "clipped_ratio": 0.5,
+          "step": 26
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 1.333e-07,
+          "num_tokens": 86700.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.4072,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.78,
+          "epoch": 0.75,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 27
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 1e-07,
+          "num_tokens": 89350.0,
+          "completions/mean_length": 256.0,
+          "completions/min_length": 256.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 1.0,
+          "completions/mean_terminated_length": 0.0,
+          "completions/min_terminated_length": 0.0,
+          "completions/max_terminated_length": 0.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.5724,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.85,
+          "epoch": 0.7778,
+          "completion_length": 256.0,
+          "clipped_ratio": 1.0,
+          "step": 28
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 6.667e-08,
+          "num_tokens": 92410.0,
+          "completions/mean_length": 151.5,
+          "completions/min_length": 47.0,
+          "completions/max_length": 256.0,
+          "completions/clipped_ratio": 0.5,
+          "completions/mean_terminated_length": 47.0,
+          "completions/min_terminated_length": 47.0,
+          "completions/max_terminated_length": 47.0,
+          "rewards/reward_completions/mean": -8.0,
+          "rewards/reward_completions/std": 0.0,
+          "reward": -8.0,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.5002,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.8,
+          "epoch": 0.8056,
+          "completion_length": 151.5,
+          "clipped_ratio": 0.5,
+          "step": 29
+        },
+        {
+          "loss": 0.0,
+          "grad_norm": 0.0,
+          "learning_rate": 3.333e-08,
+          "num_tokens": 94650.0,
+          "completions/mean_length": 229.0,
+          "completions/min_length": 210.0,
+          "completions/max_length": 248.0,
+          "completions/clipped_ratio": 0.0,
+          "completions/mean_terminated_length": 229.0,
+          "completions/min_terminated_length": 210.0,
+          "completions/max_terminated_length": 248.0,
+          "rewards/reward_completions/mean": 0.001667,
+          "rewards/reward_completions/std": 0.0,
+          "reward": 0.001667,
+          "reward_std": 0.0,
+          "frac_reward_zero_std": 1.0,
+          "entropy": 0.79,
+          "clip_ratio/low_mean": 0.0,
+          "clip_ratio/low_min": 0.0,
+          "clip_ratio/high_mean": 0.0,
+          "clip_ratio/high_max": 0.0,
+          "clip_ratio/region_mean": 0.0,
+          "step_time": 14.23,
+          "epoch": 0.8333,
+          "completion_length": 229.0,
+          "clipped_ratio": 0.0,
+          "step": 30
+        }
+      ],
+      "reward_batches": [
+        {
+          "call": 1,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 2,
+          "max_reward": -8.0,
+          "mean_reward": -8.0,
+          "message": "reward_batch",
+          "min_reward": -8.0,
+          "role": "warehouse"
+        },
+        {
+          "call": 10,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 1,
+          "max_reward": -0.6396,
+          "mean_reward": -4.3198,
+          "message": "reward_batch",
+          "min_reward": -8.0,
+          "role": "warehouse"
+        },
+        {
+          "call": 20,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 0,
+          "max_reward": 0.932,
+          "mean_reward": 0.932,
+          "message": "reward_batch",
+          "min_reward": 0.932,
+          "role": "warehouse"
+        },
+        {
+          "call": 30,
+          "count": 2,
+          "invalid_actions": 0,
+          "invalid_payloads": 0,
+          "max_reward": 0.0017,
+          "mean_reward": 0.0017,
+          "message": "reward_batch",
+          "min_reward": 0.0017,
+          "role": "warehouse"
+        }
+      ]
+    }
+  },
+  "training_summary": {
+    "center": {
+      "steps": 30,
+      "reward_batches": 4,
+      "invalid_payloads": 6,
+      "invalid_actions": 0,
+      "first_reward": -8.0,
+      "last_reward": -8.0,
+      "best_reward": 2.848,
+      "mean_reward": -4.0082933333333335,
+      "first_loss": 0.0,
+      "last_loss": 0.0,
+      "mean_loss": 0.14594833333333335,
+      "mean_clipped_ratio": 0.5666666666666667,
+      "mean_completion_length": 207.48333333333332
+    },
+    "warehouse": {
+      "steps": 30,
+      "reward_batches": 4,
+      "invalid_payloads": 3,
+      "invalid_actions": 0,
+      "first_reward": -8.0,
+      "last_reward": 0.001667,
+      "best_reward": 0.932,
+      "mean_reward": -5.4457011,
+      "first_loss": 0.0,
+      "last_loss": 0.0,
+      "mean_loss": 0.09703366666666667,
+      "mean_clipped_ratio": 0.5833333333333334,
+      "mean_completion_length": 189.33333333333334
+    }
+  }
 }

scripts/hf_eval_supplymind_adapters.py

@@ -38,7 +38,9 @@ def log(message: str, **fields: Any) -> None:
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
     parser.add_argument("--role", choices=["center", "warehouse"], required=True)
-    parser.add_argument("--adapter-id", required=True)
+    parser.add_argument("--adapter-id", default="")
+    parser.add_argument("--sft-adapter-id", default="")
+    parser.add_argument("--grpo-adapter-id", default="")
     parser.add_argument("--task-id", default="v2_train_easy")
     parser.add_argument("--seeds", default="101,113,127")
     parser.add_argument("--max-new-tokens", type=int, default=256)
@@ -197,6 +199,8 @@ def evaluate(role: str, label: str, model: Any, tokenizer: Any, task_id: str, se
 def main() -> None:
     started = time.time()
     args = parse_args()
+    if not (args.adapter_id or args.sft_adapter_id or args.grpo_adapter_id):
+        raise SystemExit("Provide --adapter-id or --sft-adapter-id/--grpo-adapter-id.")
     prepare_repo()
     seeds = [int(value.strip()) for value in args.seeds.split(",") if value.strip()]
 
@@ -207,11 +211,23 @@ def main() -> None:
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
 
-    log("loading_adapter_model", adapter_id=args.adapter_id)
-    adapter_model, tokenizer = load_model(args.adapter_id)
-    trained = evaluate(args.role, "adapter", adapter_model, tokenizer, args.task_id, seeds, args.max_new_tokens)
-
-    result = {"message": "eval_done", "elapsed_seconds": round(time.time() - started, 2), "base": base, "adapter": trained}
+    evaluations: dict[str, Any] = {"base": base}
+    adapter_specs = []
+    if args.adapter_id:
+        adapter_specs.append(("adapter", args.adapter_id))
+    if args.sft_adapter_id:
+        adapter_specs.append(("sft", args.sft_adapter_id))
+    if args.grpo_adapter_id:
+        adapter_specs.append(("grpo", args.grpo_adapter_id))
+    for label, adapter_id in adapter_specs:
+        log("loading_adapter_model", label=label, adapter_id=adapter_id)
+        adapter_model, tokenizer = load_model(adapter_id)
+        evaluations[label] = evaluate(args.role, label, adapter_model, tokenizer, args.task_id, seeds, args.max_new_tokens)
+        del adapter_model
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    result = {"message": "eval_done", "elapsed_seconds": round(time.time() - started, 2), **evaluations}
     log(**result)
 
 

scripts/hf_sft_supplymind_roles.py

@@ -0,0 +1,258 @@
+# /// script
+# dependencies = [
+#   "torch",
+#   "transformers>=4.45.0",
+#   "peft>=0.13.0",
+#   "accelerate",
+#   "datasets",
+#   "huggingface_hub",
+#   "pydantic",
+#   "pyyaml",
+# ]
+# ///
+from __future__ import annotations
+
+import argparse
+import inspect
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from statistics import mean
+from typing import Any
+
+import torch
+from datasets import Dataset
+from huggingface_hub import snapshot_download
+from peft import LoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM, AutoTokenizer, DataCollatorForLanguageModeling, Trainer, TrainingArguments
+
+
+REPO_ID = "rishavutk/supplymind"
+MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+
+
+def log(message: str, **fields: Any) -> None:
+    print(json.dumps({"message": message, **fields}, sort_keys=True), flush=True)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--role", choices=["center", "warehouse"], required=True)
+    parser.add_argument("--task-id", default="v2_train_easy")
+    parser.add_argument("--seeds", default="101,113,127")
+    parser.add_argument("--max-steps", type=int, default=80)
+    parser.add_argument("--max-length", type=int, default=2048)
+    parser.add_argument("--hub-model-id", default="")
+    parser.add_argument("--output-dir", default="")
+    return parser.parse_args()
+
+
+def prepare_repo() -> Path:
+    os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
+    os.environ["PYTHONUTF8"] = "1"
+    log("downloading_supplymind_space", repo_id=REPO_ID)
+    local_dir = Path(
+        snapshot_download(
+            repo_id=REPO_ID,
+            repo_type="space",
+            allow_patterns=["src/**", "configs/**"],
+            local_dir=Path("supplymind_snapshot").resolve(),
+        )
+    )
+    config_path = local_dir / "configs" / "supplymind_v2_rewards.yaml"
+    os.environ["SUPPLYMIND_REWARD_CONFIG"] = str(config_path)
+    sys.path.insert(0, str(local_dir / "src"))
+    log("repo_ready", path=str(local_dir), config_exists=config_path.exists())
+    return local_dir
+
+
+def compact_observation(observation: Any, role: str) -> dict[str, Any]:
+    data = observation.model_dump(mode="json")
+    data["scenario_info"].pop("public_rules", None)
+    if role == "center":
+        return {
+            "role": "center",
+            "round_index": data["round_index"],
+            "remaining_rounds": data["remaining_rounds"],
+            "task_id": data["task_id"],
+            "scenario_info": data["scenario_info"],
+            "center": data["center"],
+            "warehouse_summaries": data["center"].get("warehouse_summaries", []),
+            "market_signals": data["center"].get("market_signals", []),
+            "feedback": data.get("feedback", {}),
+        }
+    return {
+        "role": "warehouse",
+        "round_index": data["round_index"],
+        "remaining_rounds": data["remaining_rounds"],
+        "task_id": data["task_id"],
+        "scenario_info": data["scenario_info"],
+        "warehouses": data["warehouses"],
+        "pending_transfer_proposals": data["center"].get("pending_transfer_proposals", []),
+        "feedback": data.get("feedback", {}),
+    }
+
+
+def system_prompt(role: str) -> str:
+    if role == "center":
+        return (
+            "You are the center policy in SupplyMind. Return only strict JSON matching CenterAction: "
+            "central_procurements, central_liquidations, central_replenishments, inventory_transfer_proposals, offer_matches. "
+            "Warehouses are controlled by a fixed heuristic. Earn margin and a small share of realized service profit, "
+            "but avoid waste, stockouts, overpriced actions, and needless shipments."
+        )
+    return (
+        "You are the shared warehouse policy in SupplyMind, copied across all warehouses. "
+        "Return only strict JSON with key warehouse_actions mapping warehouse ids to actions. "
+        "Use order_decisions, inventory_offers, inventory_requests, transfer_responses, and local_priority. "
+        "The center is controlled by a fixed heuristic. Accept orders you can serve, request needed stock, "
+        "and reject bad or impossible commitments."
+    )
+
+
+def action_completion(role: str, joint_action: Any) -> str:
+    if role == "center":
+        payload = joint_action.central_action.model_dump(mode="json")
+    else:
+        payload = {"warehouse_actions": {key: value.model_dump(mode="json") for key, value in joint_action.warehouse_actions.items()}}
+    return json.dumps(payload, separators=(",", ":"))
+
+
+def build_rows(role: str, task_id: str, seeds: list[int], tokenizer: Any) -> list[dict[str, str]]:
+    from supplymind_env_v2.environment import V2SupplyMindEnv
+    from supplymind_env_v2.policies import heuristic_joint_policy
+
+    rows: list[dict[str, str]] = []
+    for seed in seeds:
+        env = V2SupplyMindEnv(default_task_id=task_id)
+        observation = env.reset_internal(task_id, seed)
+        while not env.done:
+            joint_action = heuristic_joint_policy(observation)
+            messages = [
+                {"role": "system", "content": system_prompt(role)},
+                {"role": "user", "content": json.dumps(compact_observation(observation, role), separators=(",", ":"))},
+                {"role": "assistant", "content": action_completion(role, joint_action)},
+            ]
+            rows.append(
+                {
+                    "text": tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False),
+                    "task_id": task_id,
+                    "seed": seed,
+                    "round_index": observation.round_index,
+                }
+            )
+            result = env.step(joint_action, grade_terminal=False)
+            observation = result.observation
+    return rows
+
+
+def baseline_probe(role: str, task_id: str, seeds: list[int]) -> None:
+    from supplymind_env_v2.environment import V2SupplyMindEnv
+    from supplymind_env_v2.policies import heuristic_joint_policy, no_op_policy
+
+    for policy_name, policy_fn in (("no_op", no_op_policy), ("heuristic", heuristic_joint_policy)):
+        summaries: list[dict[str, Any]] = []
+        for seed in seeds:
+            env = V2SupplyMindEnv(default_task_id=task_id)
+            observation = env.reset_internal(task_id, seed)
+            while not env.done:
+                result = env.step(policy_fn(observation))
+                observation = result.observation
+            summaries.append(env.last_episode_summary or {})
+        log(
+            "baseline_probe",
+            role=role,
+            policy=policy_name,
+            mean_global_score=round(mean(float(row.get("graded_score", 0.0)) for row in summaries), 4),
+            mean_center_role_score=round(mean(float(row.get("center_role_score", 0.0)) for row in summaries), 4),
+            mean_warehouse_role_score=round(mean(float(row.get("warehouse_role_score", 0.0)) for row in summaries), 4),
+            mean_raw_reward=round(mean(float(row.get("raw_reward", 0.0)) for row in summaries), 3),
+        )
+
+
+def tokenize_dataset(dataset: Dataset, tokenizer: Any, max_length: int) -> Dataset:
+    def tokenize(batch: dict[str, list[str]]) -> dict[str, Any]:
+        return tokenizer(batch["text"], truncation=True, max_length=max_length)
+
+    return dataset.map(tokenize, batched=True, remove_columns=list(dataset.column_names))
+
+
+def make_training_args(output_dir: str, max_steps: int, hub_model_id: str, role: str) -> TrainingArguments:
+    requested = {
+        "output_dir": output_dir,
+        "max_steps": max_steps,
+        "per_device_train_batch_size": 1,
+        "gradient_accumulation_steps": 2,
+        "learning_rate": 2e-4,
+        "warmup_ratio": 0.03,
+        "logging_steps": 1,
+        "report_to": [],
+        "save_strategy": "no",
+        "push_to_hub": False,
+        "hub_model_id": hub_model_id,
+        "bf16": torch.cuda.is_available() and torch.cuda.is_bf16_supported(),
+        "fp16": torch.cuda.is_available() and not torch.cuda.is_bf16_supported(),
+        "run_name": f"{role}-sft-smoke",
+    }
+    signature = inspect.signature(TrainingArguments)
+    supported = {key: value for key, value in requested.items() if key in signature.parameters}
+    dropped = sorted(set(requested) - set(supported))
+    if dropped:
+        log("training_args_dropped_unsupported_keys", dropped=dropped)
+    return TrainingArguments(**supported)
+
+
+def main() -> None:
+    started = time.time()
+    args = parse_args()
+    prepare_repo()
+    seeds = [int(value.strip()) for value in args.seeds.split(",") if value.strip()]
+    output_dir = args.output_dir or f"outputs/supplymind-{args.role}-qwen-sft"
+    hub_model_id = args.hub_model_id or f"rishavutk/supplymind-{args.role}-qwen-0.5b-sft"
+
+    log("loading_tokenizer", model_id=MODEL_ID)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    rows = build_rows(args.role, args.task_id, seeds, tokenizer)
+    dataset = Dataset.from_list(rows)
+    log("dataset_ready", role=args.role, rows=len(rows), task_id=args.task_id, seeds=seeds, hub_model_id=hub_model_id)
+    baseline_probe(args.role, args.task_id, seeds)
+
+    tokenized = tokenize_dataset(dataset, tokenizer, args.max_length)
+    log("tokenized_dataset_ready", rows=len(tokenized), max_length=args.max_length)
+
+    log("loading_model", model_id=MODEL_ID)
+    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, torch_dtype="auto", device_map="auto")
+    model = get_peft_model(
+        model,
+        LoraConfig(
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+            task_type="CAUSAL_LM",
+        ),
+    )
+    model.print_trainable_parameters()
+
+    trainer = Trainer(
+        model=model,
+        args=make_training_args(output_dir, args.max_steps, hub_model_id, args.role),
+        train_dataset=tokenized,
+        data_collator=DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False),
+    )
+    log("training_start", role=args.role, max_steps=args.max_steps)
+    trainer.train()
+    log("training_done", elapsed_seconds=round(time.time() - started, 2))
+    log("pushing_model", hub_model_id=hub_model_id)
+    model.push_to_hub(hub_model_id)
+    tokenizer.push_to_hub(hub_model_id)
+    log("job_done", hub_model_id=hub_model_id, elapsed_seconds=round(time.time() - started, 2))
+
+
+if __name__ == "__main__":
+    main()

scripts/hf_train_supplymind_roles.py

@@ -28,7 +28,7 @@ from typing import Any
 
 from datasets import Dataset
 from huggingface_hub import snapshot_download
-from peft import LoraConfig
+from peft import LoraConfig, PeftModel
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from trl import GRPOConfig, GRPOTrainer
 
@@ -38,6 +38,8 @@ MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
 REWARD_SCALE = 10.0
 REWARD_CLIP = 20.0
 REWARD_LOG_EVERY = 10
+MALFORMED_REWARD = -2.0
+INVALID_ACTION_PENALTY = 0.5
 
 
 def log(message: str, **fields: Any) -> None:
@@ -54,6 +56,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--max-completion-length", type=int, default=256)
     parser.add_argument("--hub-model-id", default="")
     parser.add_argument("--output-dir", default="")
+    parser.add_argument("--init-adapter-id", default="")
     return parser.parse_args()
 
 
@@ -204,7 +207,7 @@ def make_reward_fn(role: str):
         for completion, current_task, current_seed, current_round in zip(completions, task_id, seed, round_index, strict=True):
             payload = extract_json(completion)
             if payload is None:
-                rewards.append(-8.0)
+                rewards.append(MALFORMED_REWARD)
                 invalid_payloads += 1
                 continue
             env, observation = replay_to_round(current_task, int(current_seed), int(current_round))
@@ -222,7 +225,7 @@ def make_reward_fn(role: str):
                 else:
                     action = V2JointAction.model_validate(payload)
             except Exception:
-                rewards.append(-8.0)
+                rewards.append(MALFORMED_REWARD)
                 invalid_payloads += 1
                 continue
             result = env.step(action, grade_terminal=False)
@@ -236,7 +239,7 @@ def make_reward_fn(role: str):
             else:
                 role_delta = float(result.reward.step_reward)
             scaled = max(-REWARD_CLIP, min(REWARD_CLIP, role_delta / REWARD_SCALE))
-            rewards.append(scaled + 1.0 - 2.0 * invalid_count)
+            rewards.append(scaled + 1.0 - INVALID_ACTION_PENALTY * invalid_count)
         if call_count == 1 or call_count % REWARD_LOG_EVERY == 0:
             log(
                 "reward_batch",
@@ -338,22 +341,29 @@ def main() -> None:
     log("loading_model", model_id=MODEL_ID)
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
     model = AutoModelForCausalLM.from_pretrained(MODEL_ID, torch_dtype="auto", device_map="auto")
-    log("model_loaded", model_id=MODEL_ID)
-
-    trainer = GRPOTrainer(
-        model=model,
-        processing_class=tokenizer,
-        reward_funcs=make_reward_fn(args.role),
-        train_dataset=dataset,
-        peft_config=LoraConfig(
-            r=16,
-            lora_alpha=32,
-            lora_dropout=0.05,
-            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
-            task_type="CAUSAL_LM",
-        ),
-        args=make_grpo_config(output_dir, args.max_steps, hub_model_id, args.role, args.max_completion_length),
+    peft_config = LoraConfig(
+        r=16,
+        lora_alpha=32,
+        lora_dropout=0.05,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+        task_type="CAUSAL_LM",
     )
+    if args.init_adapter_id:
+        log("loading_initial_adapter", adapter_id=args.init_adapter_id)
+        model = PeftModel.from_pretrained(model, args.init_adapter_id, is_trainable=True)
+        peft_config = None
+    log("model_loaded", model_id=MODEL_ID, init_adapter_id=args.init_adapter_id or None)
+
+    trainer_kwargs = {
+        "model": model,
+        "processing_class": tokenizer,
+        "reward_funcs": make_reward_fn(args.role),
+        "train_dataset": dataset,
+        "args": make_grpo_config(output_dir, args.max_steps, hub_model_id, args.role, args.max_completion_length),
+    }
+    if peft_config is not None:
+        trainer_kwargs["peft_config"] = peft_config
+    trainer = GRPOTrainer(**trainer_kwargs)
     log("training_start", role=args.role, max_steps=args.max_steps, max_completion_length=args.max_completion_length)
     trainer.train()
     log("training_done", elapsed_seconds=round(time.time() - started, 2))

scripts/parse_training_logs.py

@@ -0,0 +1,287 @@
+"""Parse HF training job logs into the local training dashboard JSON."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+from statistics import mean
+from typing import Any
+
+
+DEFAULT_OUTPUT = Path("results/training_dashboard.json")
+ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+ROLE_RE = re.compile(r"\b(center|warehouse)\b", re.IGNORECASE)
+
+
+def read_text(path: Path) -> str:
+    """Read UTF-8 and PowerShell UTF-16 redirected logs."""
+    data = path.read_bytes()
+    if data.startswith((b"\xff\xfe", b"\xfe\xff")):
+        return data.decode("utf-16")
+    if data[:200].count(b"\x00") > 20:
+        return data.decode("utf-16-le")
+
+    for encoding in ("utf-8-sig", "utf-16", "utf-16-le", "utf-8", "cp1252"):
+        try:
+            return data.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    return data.decode("utf-8", errors="replace")
+
+
+def load_json(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+
+    text = read_text(path).strip()
+    if not text:
+        return {}
+
+    loaded = json.loads(text)
+    if not isinstance(loaded, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return loaded
+
+
+def to_number(value: Any) -> Any:
+    if isinstance(value, (int, float)) or value is None:
+        return value
+    if not isinstance(value, str):
+        return value
+
+    stripped = value.strip()
+    if not stripped:
+        return value
+    try:
+        return float(stripped)
+    except ValueError:
+        return value
+
+
+def normalize_mapping(values: dict[str, Any]) -> dict[str, Any]:
+    return {key: to_number(value) for key, value in values.items()}
+
+
+def parse_json_line(line: str) -> dict[str, Any] | None:
+    try:
+        parsed = json.loads(line)
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def parse_python_dict_line(line: str) -> dict[str, Any] | None:
+    if not (line.startswith("{") and line.endswith("}")):
+        return None
+    try:
+        parsed = ast.literal_eval(line)
+    except (SyntaxError, ValueError):
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def looks_like_step(record: dict[str, Any]) -> bool:
+    return any(
+        key in record
+        for key in (
+            "loss",
+            "reward",
+            "rewards/reward_completions/mean",
+            "completions/mean_length",
+            "completions/clipped_ratio",
+        )
+    ) and "train_runtime" not in record
+
+
+def infer_role(path: Path, records: list[dict[str, Any]]) -> str:
+    for record in records:
+        role = record.get("role")
+        if isinstance(role, str) and role.lower() in {"center", "warehouse"}:
+            return role.lower()
+
+    match = ROLE_RE.search(path.stem)
+    if match:
+        return match.group(1).lower()
+
+    raise ValueError(f"Could not infer role for {path}; use --center-log or --warehouse-log")
+
+
+def parse_log(path: Path, role_hint: str | None = None) -> tuple[str, dict[str, Any]]:
+    steps: list[dict[str, Any]] = []
+    reward_batches: list[dict[str, Any]] = []
+    role_records: list[dict[str, Any]] = []
+
+    for raw_line in read_text(path).splitlines():
+        line = ANSI_RE.sub("", raw_line).strip()
+        if not line:
+            continue
+
+        json_record = parse_json_line(line)
+        if json_record:
+            normalized = normalize_mapping(json_record)
+            role_records.append(normalized)
+            if normalized.get("message") == "reward_batch":
+                reward_batches.append(normalized)
+            continue
+
+        dict_record = parse_python_dict_line(line)
+        if dict_record and looks_like_step(dict_record):
+            step = normalize_mapping(dict_record)
+            step.setdefault("reward", step.get("rewards/reward_completions/mean"))
+            step.setdefault("completion_length", step.get("completions/mean_length"))
+            step.setdefault("clipped_ratio", step.get("completions/clipped_ratio"))
+            step["step"] = len(steps) + 1
+            steps.append(step)
+
+    role = role_hint or infer_role(path, role_records)
+    return role, {
+        "source_log": str(path),
+        "steps": steps,
+        "reward_batches": reward_batches,
+    }
+
+
+def parse_eval_log(path: Path) -> list[dict[str, Any]]:
+    comparisons: list[dict[str, Any]] = []
+    for raw_line in read_text(path).splitlines():
+        line = ANSI_RE.sub("", raw_line).strip()
+        if not line:
+            continue
+        record = parse_json_line(line)
+        if not record or record.get("message") != "eval_result":
+            continue
+        comparisons.append(normalize_mapping({key: value for key, value in record.items() if key != "episodes"}))
+    return comparisons
+
+
+def average(values: list[Any]) -> float | None:
+    numbers = [value for value in values if isinstance(value, (int, float))]
+    return mean(numbers) if numbers else None
+
+
+def summarize(series: dict[str, Any]) -> dict[str, Any]:
+    steps = series.get("steps", [])
+    reward_batches = series.get("reward_batches", [])
+    rewards = [step.get("reward") for step in steps]
+    losses = [step.get("loss") for step in steps]
+    clipped = [step.get("completions/clipped_ratio") for step in steps]
+    lengths = [step.get("completions/mean_length") for step in steps]
+
+    summary: dict[str, Any] = {
+        "steps": len(steps),
+        "reward_batches": len(reward_batches),
+        "invalid_payloads": sum(int(batch.get("invalid_payloads") or 0) for batch in reward_batches),
+        "invalid_actions": sum(int(batch.get("invalid_actions") or 0) for batch in reward_batches),
+    }
+
+    numeric_rewards = [value for value in rewards if isinstance(value, (int, float))]
+    if numeric_rewards:
+        summary.update(
+            {
+                "first_reward": rewards[0],
+                "last_reward": rewards[-1],
+                "best_reward": max(numeric_rewards),
+                "mean_reward": average(rewards),
+            }
+        )
+    if losses:
+        summary.update(
+            {
+                "first_loss": losses[0],
+                "last_loss": losses[-1],
+                "mean_loss": average(losses),
+            }
+        )
+
+    mean_clipped = average(clipped)
+    mean_length = average(lengths)
+    if mean_clipped is not None:
+        summary["mean_clipped_ratio"] = mean_clipped
+    if mean_length is not None:
+        summary["mean_completion_length"] = mean_length
+
+    return summary
+
+
+def discover_logs() -> list[tuple[str | None, Path]]:
+    return [(None, path) for path in sorted(Path("results").glob("*.log"))]
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--center-log", type=Path, help="HF training log for the center role")
+    parser.add_argument("--warehouse-log", type=Path, help="HF training log for the warehouse role")
+    parser.add_argument("--eval-log", action="append", type=Path, default=[], help="HF eval log containing eval_result JSON rows")
+    parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT, help="Dashboard JSON path")
+    parser.add_argument("--status", help="Optional top-level dashboard status")
+    parser.add_argument("--updated-at", help="Optional top-level dashboard updated_at value")
+    return parser
+
+
+def main() -> None:
+    args = build_arg_parser().parse_args()
+
+    requested_logs: list[tuple[str | None, Path]] = []
+    if args.center_log:
+        requested_logs.append(("center", args.center_log))
+    if args.warehouse_log:
+        requested_logs.append(("warehouse", args.warehouse_log))
+    if not requested_logs:
+        requested_logs = discover_logs()
+
+    dashboard = load_json(args.output)
+    dashboard.setdefault("training_series", {})
+    dashboard.setdefault("training_summary", {})
+
+    parsed_roles: list[str] = []
+    for role_hint, log_path in requested_logs:
+        if not log_path.exists():
+            raise FileNotFoundError(log_path)
+        try:
+            role, series = parse_log(log_path, role_hint)
+        except ValueError:
+            if role_hint is None:
+                continue
+            raise
+        if role not in {"center", "warehouse"}:
+            continue
+        if not series.get("steps") and not series.get("reward_batches"):
+            continue
+        dashboard["training_series"][role] = series
+        dashboard["training_summary"][role] = summarize(series)
+        parsed_roles.append(role)
+
+    comparisons: list[dict[str, Any]] = []
+    for eval_log in args.eval_log:
+        if not eval_log.exists():
+            raise FileNotFoundError(eval_log)
+        comparisons.extend(parse_eval_log(eval_log))
+    if comparisons:
+        seen: set[tuple[str, str]] = set()
+        unique = []
+        for row in reversed(comparisons):
+            key = (str(row.get("role")), str(row.get("label")))
+            if key in seen:
+                continue
+            seen.add(key)
+            unique.append(row)
+        dashboard["comparisons"] = list(reversed(unique))
+
+    if args.status:
+        dashboard["status"] = args.status
+    if args.updated_at:
+        dashboard["updated_at"] = args.updated_at
+    elif parsed_roles and "updated_at" not in dashboard:
+        dashboard["updated_at"] = datetime.now().astimezone().isoformat(timespec="seconds")
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(dashboard, indent=2) + "\n", encoding="utf-8")
+    print(f"Wrote {args.output} with roles: {', '.join(parsed_roles) or 'none'}")
+
+
+if __name__ == "__main__":
+    main()

static/dashboard.html

@@ -3,46 +3,63 @@
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>SupplyMind Training Dashboard</title>
+  <title>SupplyMind Experiment Analysis</title>
   <style>
     :root {
-      --bg:#eef5fb; --ink:#152033; --muted:#66768d; --panel:#ffffff; --line:#d6e0ea;
-      --nav:#0f2535; --blue:#2563eb; --cyan:#0891b2; --green:#047857; --red:#b42318; --amber:#b7791f;
+      --bg:#f4f7fb; --ink:#172033; --muted:#667085; --panel:#ffffff; --line:#d8e0ea;
+      --nav:#102236; --blue:#2563eb; --teal:#0f766e; --red:#c2410c; --amber:#b7791f;
+      --green:#047857; --grid:#e8edf3;
     }
     * { box-sizing:border-box; }
     body { margin:0; font-family:Inter, Segoe UI, Arial, sans-serif; background:var(--bg); color:var(--ink); }
-    header { background:var(--nav); color:white; padding:16px 20px; display:flex; justify-content:space-between; align-items:center; gap:14px; flex-wrap:wrap; }
-    h1 { margin:0; font-size:22px; font-weight:700; }
-    h2 { margin:0 0 10px; font-size:15px; }
-    main { padding:16px; display:grid; gap:14px; max-width:1360px; margin:0 auto; }
-    section, .card { background:var(--panel); border:1px solid var(--line); border-radius:8px; padding:12px; }
-    .top { display:grid; grid-template-columns:1fr 1fr 1fr 1fr; gap:10px; }
-    .metric strong { display:block; font-size:24px; margin-top:4px; }
-    .muted { color:var(--muted); }
-    .grid { display:grid; grid-template-columns:1.1fr .9fr; gap:14px; }
-    .plots { display:grid; grid-template-columns:1fr 1fr; gap:14px; }
-    .status { display:flex; gap:8px; align-items:center; flex-wrap:wrap; }
-    .pill { border-radius:999px; border:1px solid #bfdbfe; background:#eff6ff; color:#1d4ed8; padding:3px 9px; font-size:12px; }
-    .pill.good { background:#ecfdf5; border-color:#a7f3d0; color:#047857; }
-    .pill.bad { background:#fef2f2; border-color:#fecaca; color:#b42318; }
-    .pill.warn { background:#fffbeb; border-color:#fde68a; color:#92400e; }
+    header { background:var(--nav); color:white; padding:18px 22px; display:flex; justify-content:space-between; align-items:center; gap:14px; flex-wrap:wrap; }
+    h1 { margin:0; font-size:22px; font-weight:750; letter-spacing:0; }
+    h2 { margin:0; font-size:15px; font-weight:700; }
+    main { max-width:1440px; margin:0 auto; padding:16px; display:grid; gap:14px; }
+    section { background:var(--panel); border:1px solid var(--line); border-radius:8px; padding:14px; }
     button, a.button { height:34px; border-radius:6px; border:0; background:var(--blue); color:white; padding:8px 12px; cursor:pointer; text-decoration:none; font:inherit; display:inline-flex; align-items:center; }
-    a.link { color:#bfdbfe; text-decoration:none; }
-    table { width:100%; border-collapse:collapse; font-size:13px; }
-    th,td { padding:8px; border-bottom:1px solid var(--line); text-align:left; vertical-align:top; }
-    th { color:#42536a; font-weight:600; background:#f8fafc; }
-    canvas { width:100%; height:300px; display:block; }
-    .legend { display:flex; gap:12px; flex-wrap:wrap; margin-top:8px; font-size:12px; color:var(--muted); }
+    a.link { color:#dbeafe; text-decoration:none; }
+    .muted { color:var(--muted); }
+    .subtle { color:#cbd5e1; font-size:13px; margin-top:4px; }
+    .status { display:flex; gap:9px; align-items:center; flex-wrap:wrap; }
+    .pill { border-radius:999px; border:1px solid #bfdbfe; background:#eff6ff; color:#1d4ed8; padding:4px 10px; font-size:12px; white-space:nowrap; }
+    .summary { display:grid; grid-template-columns:repeat(5, minmax(0, 1fr)); gap:10px; }
+    .metric { border:1px solid var(--line); border-radius:8px; padding:11px 12px; background:#fbfdff; min-height:82px; }
+    .metric span { display:block; color:var(--muted); font-size:12px; }
+    .metric strong { display:block; margin-top:8px; font-size:24px; line-height:1; }
+    .metric small { display:block; margin-top:7px; color:var(--muted); font-size:12px; }
+    .chart-grid { display:grid; grid-template-columns:1fr 1fr; gap:14px; }
+    .wide { grid-column:1 / -1; }
+    .chart-head { display:flex; justify-content:space-between; gap:12px; align-items:flex-start; margin-bottom:8px; }
+    .legend { display:flex; gap:12px; flex-wrap:wrap; font-size:12px; color:var(--muted); justify-content:flex-end; }
     .swatch { width:10px; height:10px; border-radius:2px; display:inline-block; margin-right:5px; }
-    pre { background:#0f172a; color:#e2e8f0; padding:10px; border-radius:8px; max-height:260px; overflow:auto; font-size:12px; }
-    @media (max-width:960px) { .top,.grid,.plots { grid-template-columns:1fr; } }
+    canvas { display:block; width:100%; height:320px; }
+    .wide canvas { height:360px; }
+    table { width:100%; border-collapse:collapse; font-size:13px; }
+    th, td { padding:9px 8px; border-bottom:1px solid var(--line); text-align:left; vertical-align:top; }
+    th { background:#f8fafc; color:#42536a; font-weight:700; }
+    td.number { font-variant-numeric:tabular-nums; }
+    .delta.good { color:var(--green); font-weight:700; }
+    .delta.bad { color:var(--red); font-weight:700; }
+    .empty { color:var(--muted); padding:24px; text-align:center; border:1px dashed var(--line); border-radius:8px; background:#fbfdff; }
+    @media (max-width:1100px) {
+      .summary { grid-template-columns:repeat(2, minmax(0, 1fr)); }
+      .chart-grid { grid-template-columns:1fr; }
+      .wide { grid-column:auto; }
+    }
+    @media (max-width:640px) {
+      header { align-items:flex-start; }
+      main { padding:10px; }
+      .summary { grid-template-columns:1fr; }
+      canvas, .wide canvas { height:280px; }
+    }
   </style>
 </head>
 <body>
   <header>
     <div>
-      <h1>SupplyMind Training Dashboard</h1>
-      <div class="muted" style="color:#cbd5e1">Role-specific GRPO smoke runs, adapter evals, and training signals</div>
+      <h1>SupplyMind Experiment Analysis</h1>
+      <div class="subtle">Training curves, reward quality, and held-out adapter comparisons</div>
     </div>
     <div class="status">
       <a class="link" href="/v2/ui">Episode UI</a>
@@ -52,151 +69,362 @@
   </header>
 
   <main>
-    <section class="top" id="summary"></section>
+    <section class="summary" id="summary"></section>
+
+    <div class="chart-grid">
+      <section class="wide">
+        <div class="chart-head">
+          <h2>Loss Over Step</h2>
+          <div class="legend">
+            <span><span class="swatch" style="background:#2563eb"></span>center</span>
+            <span><span class="swatch" style="background:#0f766e"></span>warehouse</span>
+          </div>
+        </div>
+        <canvas id="lossPlot" width="1200" height="360"></canvas>
+      </section>
 
-    <div class="plots">
       <section>
-        <h2>Before vs After Scores</h2>
-        <canvas id="scorePlot" width="760" height="320"></canvas>
-        <div class="legend">
-          <span><span class="swatch" style="background:#2563eb"></span>Base</span>
-          <span><span class="swatch" style="background:#0891b2"></span>Trained adapter</span>
+        <div class="chart-head">
+          <h2>Reward Over Step</h2>
+          <div class="legend">
+            <span><span class="swatch" style="background:#2563eb"></span>center</span>
+            <span><span class="swatch" style="background:#0f766e"></span>warehouse</span>
+          </div>
         </div>
+        <canvas id="rewardPlot" width="760" height="320"></canvas>
       </section>
+
       <section>
-        <h2>Invalid Payloads / Actions</h2>
-        <canvas id="invalidPlot" width="760" height="320"></canvas>
-        <div class="legend">
-          <span><span class="swatch" style="background:#b42318"></span>Invalid payloads</span>
-          <span><span class="swatch" style="background:#b7791f"></span>Invalid actions</span>
+        <div class="chart-head">
+          <h2>Invalid Payload / Action Batches</h2>
+          <div class="legend">
+            <span><span class="swatch" style="background:#c2410c"></span>payloads</span>
+            <span><span class="swatch" style="background:#b7791f"></span>actions</span>
+          </div>
         </div>
+        <canvas id="invalidPlot" width="760" height="320"></canvas>
       </section>
-    </div>
 
-    <div class="grid">
       <section>
-        <h2>Run Status</h2>
-        <table>
-          <thead><tr><th>Role</th><th>Job</th><th>Hardware</th><th>Status</th><th>Notes</th></tr></thead>
-          <tbody id="runs"></tbody>
-        </table>
+        <div class="chart-head">
+          <h2>Completion Length</h2>
+          <div class="legend">
+            <span><span class="swatch" style="background:#2563eb"></span>center</span>
+            <span><span class="swatch" style="background:#0f766e"></span>warehouse</span>
+          </div>
+        </div>
+        <canvas id="lengthPlot" width="760" height="320"></canvas>
       </section>
+
       <section>
-        <h2>Eval Details</h2>
-        <table>
-          <thead><tr><th>Role</th><th>Model</th><th>Global</th><th>Role Score</th><th>Raw</th></tr></thead>
-          <tbody id="comparisons"></tbody>
-        </table>
+        <div class="chart-head">
+          <h2>Clipped Ratio</h2>
+          <div class="legend">
+            <span><span class="swatch" style="background:#2563eb"></span>center</span>
+            <span><span class="swatch" style="background:#0f766e"></span>warehouse</span>
+          </div>
+        </div>
+        <canvas id="clipPlot" width="760" height="320"></canvas>
       </section>
     </div>
 
     <section>
-      <h2>Raw Dashboard JSON</h2>
-      <pre id="raw">{}</pre>
+      <div class="chart-head">
+        <h2>Held-out Comparison</h2>
+        <div class="muted" id="comparisonNote"></div>
+      </div>
+      <table>
+        <thead>
+          <tr>
+            <th>Role</th>
+            <th>Variant</th>
+            <th>Base Global</th>
+            <th>Variant Global</th>
+            <th>Global Delta</th>
+            <th>Base Role</th>
+            <th>Variant Role</th>
+            <th>Role Delta</th>
+            <th>Invalids</th>
+            <th>Raw Reward Delta</th>
+          </tr>
+        </thead>
+        <tbody id="heldout"></tbody>
+      </table>
     </section>
   </main>
 
   <script>
     const $ = id => document.getElementById(id);
+    const roles = [
+      { key:"center", label:"center", color:"#2563eb" },
+      { key:"warehouse", label:"warehouse", color:"#0f766e" },
+    ];
+    const fmt = (value, digits = 3) => {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return "pending";
+      if (Math.abs(n) >= 100) return n.toFixed(1);
+      if (Math.abs(n) >= 10) return n.toFixed(2);
+      return n.toFixed(digits);
+    };
     const roleScoreKey = role => role === "center" ? "mean_center_role_score" : "mean_warehouse_role_score";
-    const fmt = value => value === null || value === undefined || Number.isNaN(Number(value)) ? "pending" : Number(value).toFixed(4);
-    const statusClass = status => status === "completed" ? "good" : status === "error" || status === "canceled" ? "bad" : "warn";
+    const val = (row, keys) => {
+      for (const key of keys) {
+        if (row && row[key] !== undefined && row[key] !== null && Number.isFinite(Number(row[key]))) return Number(row[key]);
+      }
+      return null;
+    };
 
     async function load() {
-      const res = await fetch("/v2/training-results?ts=" + Date.now());
-      const data = await res.json();
-      $("loaded").textContent = data.updated_at || data.status || "loaded";
-      $("raw").textContent = JSON.stringify(data, null, 2);
-      renderSummary(data);
-      renderRuns(data.runs || []);
-      renderComparisons(data.comparisons || []);
-      drawScorePlot(data.comparisons || []);
-      drawInvalidPlot(data.comparisons || []);
-    }
-
-    function renderSummary(data) {
-      const comps = data.comparisons || [];
-      const completed = (data.runs || []).filter(r => r.status === "completed").length;
-      const center = improvement(comps, "center");
-      const warehouse = improvement(comps, "warehouse");
-      $("summary").innerHTML = `
-        <div class="card metric"><span class="muted">Completed jobs</span><strong>${completed}</strong></div>
-        <div class="card metric"><span class="muted">Center role lift</span><strong>${center}</strong></div>
-        <div class="card metric"><span class="muted">Warehouse role lift</span><strong>${warehouse}</strong></div>
-        <div class="card metric"><span class="muted">Hardware</span><strong>${data.hardware || "a10g-small"}</strong></div>`;
-    }
-
-    function improvement(comps, role) {
-      const base = comps.find(c => c.role === role && c.label === "base");
-      const adapter = comps.find(c => c.role === role && c.label === "adapter");
-      if (!base || !adapter) return "pending";
-      const key = roleScoreKey(role);
-      const delta = Number(adapter[key]) - Number(base[key]);
-      return (delta >= 0 ? "+" : "") + delta.toFixed(4);
-    }
-
-    function renderRuns(runs) {
-      $("runs").innerHTML = runs.map(r => `
-        <tr>
-          <td>${r.role || ""}</td>
-          <td><span class="muted">${r.job_id || ""}</span></td>
-          <td>${r.hardware || ""}</td>
-          <td><span class="pill ${statusClass(r.status)}">${r.status || "pending"}</span></td>
-          <td>${r.notes || ""}</td>
-        </tr>`).join("");
+      try {
+        const res = await fetch("/v2/training-results?ts=" + Date.now());
+        if (!res.ok) throw new Error("HTTP " + res.status);
+        const data = await res.json();
+        $("loaded").textContent = data.updated_at || data.status || "loaded";
+        render(data);
+      } catch (error) {
+        $("loaded").textContent = "failed";
+        $("summary").innerHTML = `<div class="empty" style="grid-column:1/-1">Could not load /v2/training-results: ${escapeHtml(error.message)}</div>`;
+      }
     }
 
-    function renderComparisons(comps) {
-      $("comparisons").innerHTML = comps.map(c => `
-        <tr>
-          <td>${c.role}</td>
-          <td>${c.label}</td>
-          <td>${fmt(c.mean_global_score)}</td>
-          <td>${fmt(c[roleScoreKey(c.role)])}</td>
-          <td>${fmt(c.mean_raw_reward)}</td>
-        </tr>`).join("");
-    }
-
-    function drawScorePlot(comps) {
-      const rows = ["center", "warehouse"].flatMap(role => {
-        const base = comps.find(c => c.role === role && c.label === "base");
-        const adapter = comps.find(c => c.role === role && c.label === "adapter");
-        return [{ label:`${role} base`, value:base?.[roleScoreKey(role)], color:"#2563eb" }, { label:`${role} trained`, value:adapter?.[roleScoreKey(role)], color:"#0891b2" }];
+    function render(data) {
+      const series = data.training_series || {};
+      renderSummary(data, series);
+      drawLineChart("lossPlot", lineSeries(series, ["loss"]), "loss");
+      drawLineChart("rewardPlot", lineSeries(series, ["reward", "rewards/reward_completions/mean"]), "reward");
+      drawInvalidChart("invalidPlot", invalidSeries(series));
+      drawLineChart("lengthPlot", lineSeries(series, ["completions/mean_length", "completion_length", "mean_completion_length"]), "tokens");
+      drawLineChart("clipPlot", lineSeries(series, ["completions/clipped_ratio", "clipped_ratio"]), "ratio", { minY:0, maxY:1 });
+      renderHeldout(data.comparisons || []);
+    }
+
+    function renderSummary(data, series) {
+      const summary = data.training_summary || {};
+      const allSteps = roles.flatMap(role => (series[role.key]?.steps || []).map(step => ({ role:role.key, step })));
+      const lastRows = roles.map(role => {
+        const steps = series[role.key]?.steps || [];
+        return { role:role.key, row:steps[steps.length - 1], summary:summary[role.key] || {} };
       });
-      drawBars("scorePlot", rows, 1.0);
-    }
-
-    function drawInvalidPlot(comps) {
-      const rows = comps.flatMap(c => [
-        { label:`${c.role} ${c.label} payload`, value:c.invalid_payloads, color:"#b42318" },
-        { label:`${c.role} ${c.label} action`, value:c.invalid_actions, color:"#b7791f" },
-      ]);
-      drawBars("invalidPlot", rows, Math.max(1, ...rows.map(r => Number(r.value || 0))));
-    }
-
-    function drawBars(id, rows, maxValue) {
-      const canvas = $(id), ctx = canvas.getContext("2d");
-      ctx.clearRect(0,0,canvas.width,canvas.height);
-      ctx.font = "12px Segoe UI";
-      ctx.fillStyle = "#64748b";
-      ctx.fillText("0", 154, 292);
-      ctx.fillText(String(maxValue.toFixed ? maxValue.toFixed(2) : maxValue), 690, 292);
-      rows.forEach((row, i) => {
-        const y = 26 + i * 34;
-        const value = Number(row.value || 0);
-        const width = Math.max(0, Math.min(520, (value / maxValue) * 520));
-        ctx.fillStyle = "#42536a";
-        ctx.fillText(row.label, 12, y + 17);
-        ctx.fillStyle = "#e2e8f0";
-        ctx.fillRect(155, y, 520, 18);
-        ctx.fillStyle = row.color;
-        ctx.fillRect(155, y, width, 18);
-        ctx.fillStyle = "#172033";
-        ctx.fillText(fmt(value), 688, y + 14);
+      const bestReward = Math.max(...allSteps.map(item => val(item.step, ["reward", "rewards/reward_completions/mean"]) ?? -Infinity));
+      const meanClip = avg(lastRows.map(item => item.summary.mean_clipped_ratio));
+      const meanLength = avg(lastRows.map(item => item.summary.mean_completion_length));
+      const totalInvalidPayloads = roles.reduce((sum, role) => sum + (series[role.key]?.reward_batches || []).reduce((s, b) => s + Number(b.invalid_payloads || 0), 0), 0);
+      const totalInvalidActions = roles.reduce((sum, role) => sum + (series[role.key]?.reward_batches || []).reduce((s, b) => s + Number(b.invalid_actions || 0), 0), 0);
+      $("summary").innerHTML = [
+        metric("Status", data.status || "pending", data.summary || ""),
+        metric("Steps", String(Math.max(0, ...lastRows.map(item => Number(item.summary.steps || item.row?.step || 0)))), data.hardware || ""),
+        metric("Best reward", bestReward === -Infinity ? "pending" : fmt(bestReward), "highest training step reward"),
+        metric("Mean length", fmt(meanLength, 1), "completion tokens"),
+        metric("Invalid batches", `${totalInvalidPayloads} / ${totalInvalidActions}`, "payloads / actions"),
+        metric("Mean clipped", fmt(meanClip, 3), "across role summaries"),
+      ].join("");
+    }
+
+    function metric(label, value, note) {
+      return `<div class="metric"><span>${escapeHtml(label)}</span><strong>${escapeHtml(value)}</strong><small>${escapeHtml(note || "")}</small></div>`;
+    }
+
+    function lineSeries(trainingSeries, keys) {
+      return roles.map(role => ({
+        label: role.label,
+        color: role.color,
+        points: (trainingSeries[role.key]?.steps || [])
+          .map(row => ({ x:val(row, ["step", "global_step"]), y:val(row, keys) }))
+          .filter(point => point.x !== null && point.y !== null),
+      }));
+    }
+
+    function invalidSeries(trainingSeries) {
+      const out = [];
+      for (const role of roles) {
+        for (const kind of [
+          { key:"invalid_payloads", label:"payloads", color:"#c2410c" },
+          { key:"invalid_actions", label:"actions", color:"#b7791f" },
+        ]) {
+          out.push({
+            label: `${role.label} ${kind.label}`,
+            color: kind.color,
+            points: (trainingSeries[role.key]?.reward_batches || [])
+              .map(row => ({ x:val(row, ["call", "step"]), y:val(row, [kind.key]) }))
+              .filter(point => point.x !== null && point.y !== null),
+          });
+        }
+      }
+      return out;
+    }
+
+    function drawLineChart(id, series, yLabel, options = {}) {
+      const canvas = $(id);
+      const ctx = prepCanvas(canvas);
+      const bounds = chartBounds(canvas);
+      const points = series.flatMap(s => s.points);
+      if (!points.length) return drawEmpty(ctx, canvas, "No training series found");
+      const minX = Math.min(...points.map(p => p.x));
+      const maxX = Math.max(...points.map(p => p.x));
+      let minY = options.minY ?? Math.min(...points.map(p => p.y));
+      let maxY = options.maxY ?? Math.max(...points.map(p => p.y));
+      if (minY === maxY) { minY -= 1; maxY += 1; }
+      drawAxes(ctx, bounds, minX, maxX, minY, maxY, yLabel);
+      for (const item of series) {
+        drawPath(ctx, bounds, item.points, minX, maxX, minY, maxY, item.color);
+      }
+    }
+
+    function drawInvalidChart(id, series) {
+      const canvas = $(id);
+      const ctx = prepCanvas(canvas);
+      const bounds = chartBounds(canvas);
+      const points = series.flatMap(s => s.points);
+      if (!points.length) return drawEmpty(ctx, canvas, "No reward batch diagnostics found");
+      const minX = Math.min(...points.map(p => p.x));
+      const maxX = Math.max(...points.map(p => p.x));
+      const maxY = Math.max(1, ...points.map(p => p.y));
+      drawAxes(ctx, bounds, minX, maxX, 0, maxY, "count");
+      series.forEach((item, index) => {
+        const offset = (index - 1.5) * 5;
+        drawBars(ctx, bounds, item.points, minX, maxX, 0, maxY, item.color, offset);
       });
     }
 
+    function prepCanvas(canvas) {
+      const ratio = window.devicePixelRatio || 1;
+      const rect = canvas.getBoundingClientRect();
+      canvas.width = Math.max(320, Math.round(rect.width * ratio));
+      canvas.height = Math.max(220, Math.round(rect.height * ratio));
+      const ctx = canvas.getContext("2d");
+      ctx.setTransform(ratio, 0, 0, ratio, 0, 0);
+      ctx.clearRect(0, 0, rect.width, rect.height);
+      ctx.font = "12px Segoe UI, Arial";
+      ctx.lineCap = "round";
+      ctx.lineJoin = "round";
+      return ctx;
+    }
+
+    function chartBounds(canvas) {
+      const rect = canvas.getBoundingClientRect();
+      return { left:52, top:18, right:rect.width - 18, bottom:rect.height - 34, width:rect.width, height:rect.height };
+    }
+
+    function drawAxes(ctx, b, minX, maxX, minY, maxY, yLabel) {
+      ctx.strokeStyle = "#d8e0ea";
+      ctx.lineWidth = 1;
+      ctx.fillStyle = "#667085";
+      for (let i = 0; i <= 4; i++) {
+        const y = b.bottom - ((b.bottom - b.top) * i / 4);
+        const value = minY + ((maxY - minY) * i / 4);
+        ctx.beginPath();
+        ctx.moveTo(b.left, y);
+        ctx.lineTo(b.right, y);
+        ctx.stroke();
+        ctx.fillText(fmt(value), 8, y + 4);
+      }
+      ctx.fillText(yLabel, b.left, 11);
+      ctx.fillText(String(minX), b.left, b.height - 12);
+      ctx.fillText(String(maxX), b.right - 22, b.height - 12);
+    }
+
+    function drawPath(ctx, b, points, minX, maxX, minY, maxY, color) {
+      if (!points.length) return;
+      ctx.strokeStyle = color;
+      ctx.lineWidth = 2.4;
+      ctx.beginPath();
+      points.forEach((point, index) => {
+        const x = scale(point.x, minX, maxX, b.left, b.right);
+        const y = scale(point.y, minY, maxY, b.bottom, b.top);
+        if (index === 0) ctx.moveTo(x, y);
+        else ctx.lineTo(x, y);
+      });
+      ctx.stroke();
+      ctx.fillStyle = color;
+      points.forEach(point => {
+        const x = scale(point.x, minX, maxX, b.left, b.right);
+        const y = scale(point.y, minY, maxY, b.bottom, b.top);
+        ctx.beginPath();
+        ctx.arc(x, y, 2.7, 0, Math.PI * 2);
+        ctx.fill();
+      });
+    }
+
+    function drawBars(ctx, b, points, minX, maxX, minY, maxY, color, offset) {
+      ctx.fillStyle = color;
+      const width = Math.max(3, Math.min(10, (b.right - b.left) / Math.max(12, points.length * 4)));
+      for (const point of points) {
+        const x = scale(point.x, minX, maxX, b.left, b.right) + offset;
+        const y = scale(point.y, minY, maxY, b.bottom, b.top);
+        ctx.globalAlpha = 0.82;
+        ctx.fillRect(x - width / 2, y, width, b.bottom - y);
+        ctx.globalAlpha = 1;
+      }
+    }
+
+    function renderHeldout(comparisons) {
+      const rows = [];
+      for (const role of roles) {
+        const base = comparisons.find(row => row.role === role.key && row.label === "base");
+        const variants = comparisons.filter(row => row.role === role.key && row.label !== "base");
+        for (const variant of variants) rows.push({ role:role.key, base, variant });
+      }
+      $("comparisonNote").textContent = rows.length ? "base vs SFT / GRPO variants" : "no held-out eval rows";
+      $("heldout").innerHTML = rows.length ? rows.map(row => heldoutRow(row)).join("") : `<tr><td colspan="10"><div class="empty">No held-out comparisons available.</div></td></tr>`;
+    }
+
+    function heldoutRow({ role, base, variant }) {
+      const roleKey = roleScoreKey(role);
+      const globalDelta = Number(variant?.mean_global_score) - Number(base?.mean_global_score);
+      const roleDelta = Number(variant?.[roleKey]) - Number(base?.[roleKey]);
+      const rawDelta = Number(variant?.mean_raw_reward) - Number(base?.mean_raw_reward);
+      const invalids = `${Number(variant?.invalid_payloads ?? 0)} / ${Number(variant?.invalid_actions ?? 0)}`;
+      return `
+        <tr>
+          <td>${escapeHtml(role)}</td>
+          <td>${escapeHtml(variant?.label || "variant")}</td>
+          <td class="number">${fmt(base?.mean_global_score)}</td>
+          <td class="number">${fmt(variant?.mean_global_score)}</td>
+          <td class="number ${deltaClass(globalDelta)}">${signed(globalDelta)}</td>
+          <td class="number">${fmt(base?.[roleKey])}</td>
+          <td class="number">${fmt(variant?.[roleKey])}</td>
+          <td class="number ${deltaClass(roleDelta)}">${signed(roleDelta)}</td>
+          <td class="number">${invalids}</td>
+          <td class="number ${deltaClass(rawDelta)}">${signed(rawDelta, 2)}</td>
+        </tr>`;
+    }
+
+    function deltaClass(value) {
+      if (!Number.isFinite(value) || value === 0) return "";
+      return value > 0 ? "delta good" : "delta bad";
+    }
+
+    function signed(value, digits = 3) {
+      if (!Number.isFinite(value)) return "pending";
+      return (value >= 0 ? "+" : "") + fmt(value, digits);
+    }
+
+    function scale(value, minIn, maxIn, minOut, maxOut) {
+      if (minIn === maxIn) return (minOut + maxOut) / 2;
+      return minOut + ((value - minIn) / (maxIn - minIn)) * (maxOut - minOut);
+    }
+
+    function avg(values) {
+      const nums = values.map(Number).filter(Number.isFinite);
+      return nums.length ? nums.reduce((sum, n) => sum + n, 0) / nums.length : null;
+    }
+
+    function drawEmpty(ctx, canvas, message) {
+      const rect = canvas.getBoundingClientRect();
+      ctx.fillStyle = "#667085";
+      ctx.textAlign = "center";
+      ctx.fillText(message, rect.width / 2, rect.height / 2);
+      ctx.textAlign = "left";
+    }
+
+    function escapeHtml(value) {
+      return String(value ?? "").replace(/[&<>"']/g, char => ({
+        "&":"&amp;", "<":"&lt;", ">":"&gt;", '"':"&quot;", "'":"&#39;"
+      })[char]);
+    }
+
     $("refresh").onclick = load;
+    window.addEventListener("resize", () => load());
     load();
   </script>
 </body>