@@ -627,6 +627,14 @@ can race the workers: if the process exits before they finish stopping and
 deregistering, they are orphaned — and a reused port (the next arm's server) then
 404s their heartbeats, the failure mode the worker orphan self-exit also guards.
 
+Each heartbeat that advances the aggregate appends a `(monotonic, total_tokens)`
+sample to an in-memory ring (`_record_token_sample`, only when a budget is set).
+`_token_progress()` reports completed/budget, the clamped fraction, a rolling
+tokens/sec over a recent window (`_rolling_token_rate`, ~5 min — wide because
+heartbeats are ~30 s apart) and an ETA, surfaced in `/status` as `token_progress`
+for the webui progress bar and the `forgather diloco status` line. It's a live
+gauge (in-memory, resets on restart), not persisted state.
+
 **Critical locking:**
 
 | Lock | Protects | Used by |
 
@@ -206,6 +206,21 @@ status, and DyLU configuration. The known-worker line expands into a
 **resumable roster** — the not-running worker_ids (with last-seen times) you can
 relaunch under to resume from their checkpoints.
 
+When a `--token-budget` is set, the status renders a **progress line** —
+completed/total tokens, percent, the rolling token rate, and an ETA:
+
+```
+  Token budget:  [##########--------------]  41.0%
+                 820.00M / 2.00B  ·  1.20M/s  ·  ETA 16m23s
+```
+
+The rate is averaged over a recent window (~5 min — wide on purpose, since
+heartbeats are ~30 s apart), so a sustained slowdown shows up as a falling rate
+and a climbing ETA, a quick at-a-glance health check for an open-ended run. The
+webui's DiLoCo server view shows the same as a fill bar under the header. (Both
+fall back to the plain budget count against an older server that predates the
+progress field.)
+
 Add `--queues` to also show **work-unit dispatch** per `(dataset_id,
 shuffle_seed)` queue: a human-readable dataset label (from the worker's
 load-args hint, e.g. `wikitext@train`) with the raw `dataset_id` hash kept as a
 
@@ -321,6 +321,38 @@ def _render_aggregate_stats(agg):
             print(line)
 
 
+def _fmt_tokens(n):
+    """Compact K/M/B token count, e.g. 1_500_000 -> '1.50M'."""
+    if n is None:
+        return "—"
+    n = float(n)
+    for unit, div in (("B", 1e9), ("M", 1e6), ("K", 1e3)):
+        if abs(n) >= div:
+            return f"{n / div:.2f}{unit}"
+    return f"{n:.0f}"
+
+
+def _fmt_duration(secs):
+    """Human ETA, e.g. 3725 -> '1h02m'; None/negative -> '—'."""
+    if secs is None or secs < 0:
+        return "—"
+    secs = int(secs)
+    h, rem = divmod(secs, 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h}h{m:02d}m"
+    if m:
+        return f"{m}m{s:02d}s"
+    return f"{s}s"
+
+
+def _ascii_bar(frac, width=24):
+    """A TQDM-ish ASCII bar: '[######------------------]'."""
+    frac = max(0.0, min(1.0, float(frac)))
+    filled = int(round(frac * width))
+    return "[" + "#" * filled + "-" * (width - filled) + "]"
+
+
 def render_status(merged, *, want_queues):
     """Human-readable rendering of an :func:`assemble_status` result."""
     import datetime
@@ -383,7 +415,25 @@ def render_status(merged, *, want_queues):
 
     if status.get("token_budget", 0):
         stopped = " (stop sent)" if status.get("budget_stop_sent") else ""
-        print(f"  Token budget:  {status['token_budget']:,}{stopped}")
+        prog = status.get("token_progress") or {}
+        done = prog.get("tokens_completed")
+        budget = status["token_budget"]
+        if done is not None:
+            frac = prog.get("fraction") or 0.0
+            rate = prog.get("tokens_per_second")
+            eta = prog.get("eta_seconds")
+            # A real stall reports rate 0.0 (not None) — show "0/s" (reads as
+            # "stalled") rather than "—/s" (reads as "unknown / not yet known").
+            rate_s = f"{_fmt_tokens(rate)}/s" if rate is not None else "—/s"
+            eta_s = "done" if status.get("budget_stop_sent") else _fmt_duration(eta)
+            print(f"  Token budget:  {_ascii_bar(frac)} {frac * 100:5.1f}%{stopped}")
+            print(
+                f"                 {_fmt_tokens(done)} / {_fmt_tokens(budget)}"
+                f"  ·  {rate_s}  ·  ETA {eta_s}"
+            )
+        else:
+            # Older server without token_progress.
+            print(f"  Token budget:  {budget:,}{stopped}")
 
     deaths = status.get("total_worker_deaths", 0)
     if deaths:
 
@@ -37,7 +37,7 @@
 import struct
 import threading
 import time
-from collections import defaultdict
+from collections import defaultdict, deque
 from dataclasses import dataclass, field
 from http.server import BaseHTTPRequestHandler, HTTPServer, ThreadingHTTPServer
 from typing import Any, Callable, Dict, List, Optional, Tuple
@@ -619,6 +619,16 @@ def __init__(
         # persisted, so a restart still over budget re-sends the stop.
         self.token_budget = max(0, int(token_budget))
         self._budget_stop_sent = False
+        # Rolling-rate samples for the token-budget progress / ETA — (monotonic
+        # ts, total_tokens) appended whenever a heartbeat advances the aggregate.
+        # In-memory only (a live gauge; resets on restart). The window is wide on
+        # purpose: heartbeats are ~30 s apart, so a short window would see only a
+        # sample or two and give a jittery rate. 300 s spans 6+ heartbeats per
+        # worker for a stable estimate while still reflecting a sustained
+        # slowdown within a few minutes. Not a CLI knob — tune here if ever
+        # needed. maxlen bounds memory if heartbeats are unusually dense.
+        self._token_samples: deque = deque(maxlen=512)
+        self._token_rate_window_s: float = 300.0
         # Verbose per-round sync logging (off by default). Server-authoritative:
         # advertised in /info so each worker gates its own per-round sync log to
         # match, and the server gates its per-round outer-step log. A targeted
@@ -2837,6 +2847,7 @@ def _handle_heartbeat(self, handler: BaseHTTPRequestHandler):
         # the EMA math).
         if worker_stats:
             self._stats.update(worker_id, worker_stats)
+            self._record_token_sample()
             self._maybe_trigger_token_budget()
 
         # Compute DyLU recommendation if enabled
@@ -2869,6 +2880,76 @@ def _handle_heartbeat(self, handler: BaseHTTPRequestHandler):
         if worker_stats:
             self._maybe_log_stats()
 
+    def _record_token_sample(self):
+        """Append a (monotonic ts, total_tokens) sample for the rolling rate.
+
+        No-op without a token budget (the rate/ETA is only surfaced for budgeted
+        runs). Lock-free on purpose: ``deque.append`` and the ``total_tokens``
+        int read are each atomic under the GIL, and different workers' heartbeats
+        race here (this is NOT serial-per-worker like ``pending_command``). A
+        cross-worker read could append two samples a hair out of order; the
+        ``dt<=0`` / ``dtok<0`` guards in ``_rolling_token_rate`` absorb that, and
+        a momentarily stale gauge is fine.
+        """
+        if self.token_budget <= 0:
+            return
+        self._token_samples.append((time.monotonic(), self._stats.total_tokens))
+
+    def _rolling_token_rate(self) -> Optional[float]:
+        """Tokens/second over the recent window, or None if not yet estimable.
+
+        Uses the oldest sample within ``_token_rate_window_s`` as the baseline
+        (or the oldest available if the buffer is younger than the window), so a
+        rate appears after the second heartbeat rather than waiting a full
+        window. Returns None until there are two spanning samples.
+        """
+        samples = list(self._token_samples)
+        if len(samples) < 2:
+            return None
+        now_t, now_tok = samples[-1]
+        cutoff = now_t - self._token_rate_window_s
+        base_t, base_tok = samples[0]
+        for t, tok in samples:
+            if t >= cutoff:
+                base_t, base_tok = t, tok
+                break
+        # After a long stall the only in-window sample can be the tail itself
+        # (base collapses onto ``now``). Fall back to the previous sample so we
+        # still produce a rate — a stall then reads as ~0 tok/s (the slowdown we
+        # most want visible), not a blank gauge. len>=2 guaranteed above.
+        if base_t >= now_t:
+            base_t, base_tok = samples[-2]
+        dt = now_t - base_t
+        dtok = now_tok - base_tok
+        if dt <= 0 or dtok < 0:
+            return None
+        return dtok / dt
+
+    def _token_progress(self) -> Optional[Dict[str, Any]]:
+        """Token-budget progress + rolling-rate ETA, or None when no budget.
+
+        Shape (all keys present when a budget is set):
+          tokens_completed, token_budget, fraction (0..1, clamped),
+          tokens_per_second (None until estimable), eta_seconds (None when the
+          rate is unknown or zero), rate_window_seconds, budget_stop_sent.
+        """
+        if self.token_budget <= 0:
+            return None
+        done = int(self._stats.total_tokens)
+        budget = int(self.token_budget)
+        rate = self._rolling_token_rate()
+        remaining = max(0, budget - done)
+        eta = remaining / rate if (rate and rate > 0) else None
+        return {
+            "tokens_completed": done,
+            "token_budget": budget,
+            "fraction": min(1.0, done / budget) if budget > 0 else 0.0,
+            "tokens_per_second": rate,
+            "eta_seconds": eta,
+            "rate_window_seconds": self._token_rate_window_s,
+            "budget_stop_sent": self._budget_stop_sent,
+        }
+
     def _maybe_trigger_token_budget(self):
         """When the aggregated global token count reaches ``token_budget``,
         relay ``save_and_stop`` to every worker (once). The command rides each
@@ -3176,6 +3257,10 @@ def _handle_status(self, handler: BaseHTTPRequestHandler):
         if self.token_budget > 0:
             response["token_budget"] = self.token_budget
             response["budget_stop_sent"] = self._budget_stop_sent
+            # Progress + rolling-rate ETA (tokens_completed, fraction,
+            # tokens_per_second, eta_seconds, rate_window_seconds) for the
+            # webui progress bar and the CLI status line.
+            response["token_progress"] = self._token_progress()
 
         if self.async_mode:
             response["total_submissions"] = self._total_submissions
 
@@ -150,3 +150,74 @@ def test_raise_clears_prior_stop(self, tmp_path):
             assert _pending(server, "w0") == [None]
         finally:
             server.stop()
+
+
+class TestTokenProgress:
+    """The progress/ETA gauge the webui bar and CLI status line consume."""
+
+    def test_none_without_budget(self, tmp_path):
+        server = _server(tmp_path, token_budget=0)
+        assert server._token_progress() is None
+        # No samples are recorded when there's no budget.
+        server._stats.total_tokens = 5
+        server._record_token_sample()
+        assert len(server._token_samples) == 0
+
+    def test_progress_fields_and_fraction(self, tmp_path):
+        server = _server(tmp_path, token_budget=1000)
+        server._stats.total_tokens = 250
+        prog = server._token_progress()
+        assert prog["tokens_completed"] == 250
+        assert prog["token_budget"] == 1000
+        assert prog["fraction"] == 0.25
+        assert prog["rate_window_seconds"] == server._token_rate_window_s
+        # No rate from a single sample => no ETA.
+        assert prog["tokens_per_second"] is None
+        assert prog["eta_seconds"] is None
+
+    def test_fraction_clamps_at_one(self, tmp_path):
+        server = _server(tmp_path, token_budget=1000)
+        server._stats.total_tokens = 1500  # overshoot past the budget
+        assert server._token_progress()["fraction"] == 1.0
+
+    def test_rolling_rate_and_eta(self, tmp_path):
+        server = _server(tmp_path, token_budget=2000)
+        # Seed (monotonic ts, total_tokens) samples directly: 100 tokens/10s.
+        server._token_samples.extend((1000.0 + i * 10.0, i * 100) for i in range(6))
+        server._stats.total_tokens = 500  # = last sample
+        rate = server._rolling_token_rate()
+        assert abs(rate - 10.0) < 1e-9  # 100 tokens / 10 s
+        prog = server._token_progress()
+        assert abs(prog["tokens_per_second"] - 10.0) < 1e-9
+        # remaining 1500 tokens / 10 tok/s = 150 s
+        assert abs(prog["eta_seconds"] - 150.0) < 1e-6
+
+    def test_rate_window_uses_recent_baseline(self, tmp_path):
+        server = _server(tmp_path, token_budget=10_000)
+        server._token_rate_window_s = 50.0
+        # Old slow segment then a recent fast one; only the last 50s counts.
+        samples = [(0.0, 0), (10.0, 10), (100.0, 100), (110.0, 200), (120.0, 300)]
+        server._token_samples.extend(samples)
+        server._stats.total_tokens = 300
+        # window [70,120]: baseline (100.0,100) -> (300-100)/(120-100)=10 tok/s
+        assert abs(server._rolling_token_rate() - 10.0) < 1e-9
+
+    def test_stall_reports_zero_rate_not_none(self, tmp_path):
+        """After a long stall the only in-window sample is the tail; fall back to
+        the previous sample so the gauge reads ~0 tok/s (visible slowdown), not a
+        blank None."""
+        server = _server(tmp_path, token_budget=10_000)
+        server._token_rate_window_s = 50.0
+        # All progress is old; the last two samples are flat (a stall) and only
+        # the tail falls inside the 50s window.
+        server._token_samples.extend(
+            [(0.0, 1000), (10.0, 1000), (200.0, 1000), (260.0, 1000)]
+        )
+        server._stats.total_tokens = 1000
+        rate = server._rolling_token_rate()
+        assert rate is not None
+        assert rate == 0.0  # baseline = samples[-2]=(200,1000), now=(260,1000)
+        # A 0 rate yields no ETA (can't divide), but progress still renders.
+        prog = server._token_progress()
+        assert prog["tokens_per_second"] == 0.0
+        assert prog["eta_seconds"] is None
@@ -1196,6 +1196,20 @@ export interface DiLoCoWorkerStatus {
 }
 
 /** Upstream ``/status`` response. Field set tracks DiLoCoServer._handle_status. */
+/** Token-budget progress for the dashboard bar / CLI status line. */
+export interface DiLoCoTokenProgress {
+  tokens_completed: number;
+  token_budget: number;
+  /** 0..1, clamped. */
+  fraction: number;
+  /** Rolling tokens/sec over the recent window; null until estimable. */
+  tokens_per_second: number | null;
+  /** Seconds remaining at the rolling rate; null when rate unknown/zero. */
+  eta_seconds: number | null;
+  rate_window_seconds: number;
+  budget_stop_sent: boolean;
+}
+
 export interface DiLoCoStatus {
   status?: string;
   mode?: "sync" | "async";
@@ -1217,6 +1231,8 @@ export interface DiLoCoStatus {
   min_workers?: number;
   token_budget?: number;
   budget_stop_sent?: boolean;
+  /** Token-budget progress + rolling-rate ETA (present when token_budget>0). */
+  token_progress?: DiLoCoTokenProgress;
   outer_lr?: number;
   outer_momentum?: number;
   save_dir?: string;