Fix eval countdown to use persisted next_eval_at deadline.

Store next_eval_at in eval_state.json after each run and derive the
progress bar from the absolute deadline so page reloads do not reset
the 1-hour cycle to zero.

Co-authored-by: Cursor <cursoragent@cursor.com>

app.py

@@ -102,6 +102,7 @@ def maybe_refresh_after_eval() -> tuple:
             str(eval_state.get("status", "")),
             str(eval_state.get("updated_at", "")),
             str(eval_state.get("finished_at", "")),
+            str(eval_state.get("next_eval_at_unix", "")),
         ]
     )
     if token == _last_seen_eval_token:

scripts/run_space_eval.py

@@ -24,6 +24,8 @@ from tsfm_bench.data.registry import load_data_source, load_dataset_properties
 from tsfm_bench.data.ts_bench import TsBenchDataSource
 from tsfm_bench.eval.api_predictor import DEFAULT_QUANTILES, TsfmApiConfig, TsfmApiPredictor
 from tsfm_bench.eval.online_eval import run_online_eval_for_dataset
+from src.eval_schedule import with_next_eval_fields
+from src.benchmark_config import BENCHMARK_INTERVAL_SECONDS
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
 logger = logging.getLogger(__name__)
@@ -250,29 +252,37 @@ def run_evaluation() -> int:
             },
         )
         write_eval_state(
-            {
-                "status": status,
-                "started_at": started,
-                "finished_at": finished,
-                "failed_models": failed_models,
-                "task_count": len(datasets),
-                "model_count": len(model_specs) - len(failed_models),
-                "message": "Evaluation complete",
-                "updated_at": finished,
-            }
+            with_next_eval_fields(
+                {
+                    "status": status,
+                    "started_at": started,
+                    "finished_at": finished,
+                    "failed_models": failed_models,
+                    "task_count": len(datasets),
+                    "model_count": len(model_specs) - len(failed_models),
+                    "message": "Evaluation complete",
+                    "updated_at": finished,
+                },
+                finished,
+                BENCHMARK_INTERVAL_SECONDS,
+            )
         )
         return 0 if status == "ok" else 2
     except Exception as exc:
         finished = datetime.now(timezone.utc).isoformat()
         logger.exception("Evaluation run failed")
         write_eval_state(
-            {
-                "status": "error",
-                "started_at": started,
-                "finished_at": finished,
-                "message": str(exc),
-                "updated_at": finished,
-            }
+            with_next_eval_fields(
+                {
+                    "status": "error",
+                    "started_at": started,
+                    "finished_at": finished,
+                    "message": str(exc),
+                    "updated_at": finished,
+                },
+                finished,
+                BENCHMARK_INTERVAL_SECONDS,
+            )
         )
         return 1
 

src/display/css_html_js.py

@@ -1,3 +1,10 @@
+"""Display helpers for the Gradio leaderboard."""
+
+from __future__ import annotations
+
+import time
+
+
 def build_custom_css() -> str:
     return """
 .markdown-text { font-size: 16px !important; }
@@ -29,13 +36,27 @@ def build_custom_css() -> str:
 """
 
 
+def _format_remaining(total_seconds: int) -> str:
+    total_seconds = max(0, total_seconds)
+    hours = total_seconds // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+    if hours > 0:
+        return f"{hours}h {minutes}m {seconds}s"
+    if minutes > 0:
+        return f"{minutes}m {seconds}s"
+    return f"{seconds}s"
+
+
 def eval_countdown_markup(next_eval_at_unix: int, interval_seconds: int, running: bool = False) -> str:
     if running:
         label = "Evaluation in progress…"
         progress = 0
     else:
-        label = "Next eval cycle loading…"
-        progress = 0
+        remaining = max(0, next_eval_at_unix - int(time.time()))
+        elapsed = max(0, interval_seconds - remaining)
+        progress = min(100, (elapsed / interval_seconds) * 100) if interval_seconds > 0 else 0
+        label = f"Next eval in {_format_remaining(remaining)}"
 
     return f"""
 <div class="eval-countdown-wrap" id="tsfm-eval-countdown"
@@ -44,14 +65,14 @@ def eval_countdown_markup(next_eval_at_unix: int, interval_seconds: int, running
      data-running="{'1' if running else '0'}">
   <div class="eval-countdown-label" id="tsfm-eval-countdown-label">{label}</div>
   <div class="eval-countdown-track">
-    <div class="eval-countdown-fill" id="tsfm-eval-countdown-fill" style="width: {progress}%;"></div>
+    <div class="eval-countdown-fill" id="tsfm-eval-countdown-fill" style="width: {progress:.2f}%;"></div>
   </div>
 </div>
 """
 
 
 def eval_countdown_head_js() -> str:
-    """Countdown to next eval cycle; progress bar fills as the interval elapses."""
+    """Countdown to next eval cycle; uses server-persisted absolute deadline."""
     return """
 <script>
 (function () {
@@ -90,16 +111,30 @@ def eval_countdown_head_js() -> str:
     fill.style.width = pct + "%";
   }
 
-  function start() {
+  function startInterval() {
     if (window.__tsfmEvalCountdownId) return;
-    tick();
     window.__tsfmEvalCountdownId = setInterval(tick, 1000);
   }
 
+  function boot() {
+    tick();
+    startInterval();
+    if (window.__tsfmEvalCountdownObserver) return;
+    window.__tsfmEvalCountdownObserver = new MutationObserver(function () {
+      if (document.getElementById("tsfm-eval-countdown")) {
+        tick();
+      }
+    });
+    window.__tsfmEvalCountdownObserver.observe(document.body, {
+      childList: true,
+      subtree: true,
+    });
+  }
+
   if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", start);
+    document.addEventListener("DOMContentLoaded", boot);
   } else {
-    start();
+    boot();
   }
 })();
 </script>

src/eval_schedule.py

@@ -0,0 +1,56 @@
+"""Persisted schedule for the next live evaluation cycle."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+
+from src.benchmark_config import BENCHMARK_INTERVAL_SECONDS
+
+
+def parse_iso_to_unix(value: str) -> int:
+    normalized = value.replace("Z", "+00:00")
+    return int(datetime.fromisoformat(normalized).timestamp())
+
+
+def compute_next_eval_at_iso(finished_at: str, interval_seconds: int | None = None) -> str:
+    interval = interval_seconds or BENCHMARK_INTERVAL_SECONDS
+    finished_dt = datetime.fromisoformat(finished_at.replace("Z", "+00:00"))
+    if finished_dt.tzinfo is None:
+        finished_dt = finished_dt.replace(tzinfo=timezone.utc)
+    return (finished_dt + timedelta(seconds=interval)).isoformat()
+
+
+def compute_next_eval_at_unix(
+    state: dict,
+    interval_seconds: int | None = None,
+) -> int:
+    """Absolute unix time for the next eval; survives process restarts and page reloads."""
+    interval = interval_seconds or BENCHMARK_INTERVAL_SECONDS
+
+    if state.get("status") == "running":
+        return int(datetime.now(timezone.utc).timestamp())
+
+    if raw_unix := state.get("next_eval_at_unix"):
+        return int(raw_unix)
+
+    if next_at := state.get("next_eval_at"):
+        return parse_iso_to_unix(next_at)
+
+    anchor = state.get("finished_at") or state.get("updated_at")
+    if anchor:
+        return parse_iso_to_unix(anchor) + interval
+
+    return int(datetime.now(timezone.utc).timestamp()) + interval
+
+
+def with_next_eval_fields(
+    payload: dict,
+    finished_at: str,
+    interval_seconds: int | None = None,
+) -> dict:
+    interval = interval_seconds or BENCHMARK_INTERVAL_SECONDS
+    next_at = compute_next_eval_at_iso(finished_at, interval)
+    enriched = dict(payload)
+    enriched["next_eval_at"] = next_at
+    enriched["next_eval_at_unix"] = parse_iso_to_unix(next_at)
+    return enriched

src/eval_scheduler.py

@@ -13,6 +13,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from src.benchmark_config import BENCHMARK_INTERVAL_SECONDS
+from src.eval_schedule import compute_next_eval_at_unix, with_next_eval_fields
 
 logger = logging.getLogger(__name__)
 
@@ -77,10 +78,15 @@ class LiveEvalScheduler:
         return max(0, int(self._next_run_at - time.monotonic()))
 
     def next_eval_at_unix(self) -> int:
+        state = self.snapshot()
+        persisted = compute_next_eval_at_unix(state, self.interval_seconds)
+
         remaining = self.seconds_until_next_run()
         if remaining is None:
-            return int(time.time()) + self.interval_seconds
-        return int(time.time()) + remaining
+            return persisted
+
+        in_memory = int(time.time()) + remaining
+        return min(persisted, in_memory)
 
     def is_running(self) -> bool:
         return self.snapshot().get("status") == "running"
@@ -104,6 +110,23 @@ class LiveEvalScheduler:
         finally:
             self._lock.release()
             self._next_run_at = time.monotonic() + self.interval_seconds
+            self._persist_next_eval_after_run()
+
+    def _persist_next_eval_after_run(self) -> None:
+        state_path = SPACE_ROOT / "results" / "eval_state.json"
+        if not state_path.exists():
+            return
+        try:
+            state = json.loads(state_path.read_text())
+        except json.JSONDecodeError:
+            return
+        if state.get("status") == "running":
+            return
+        anchor = state.get("finished_at") or state.get("updated_at")
+        if not anchor:
+            return
+        enriched = with_next_eval_fields(state, anchor, self.interval_seconds)
+        state_path.write_text(json.dumps(enriched, indent=4) + "\n")
 
     def _write_idle_state(self, message: str) -> None:
         results = SPACE_ROOT / "results"