dashboard: land Rollouts on the newest step that has data

miles/dashboard/README.md

@@ -52,7 +52,9 @@ Views:
   lane-selection grammar (`g:` / `rank:` / `node:` / `every:`) and outlier
   quick-picks.
 - **Rollouts** — per-step trajectory table and scatter, GRPO group degeneracy
-  (`zero_std`), average weight-version staleness, eval tab.
+  (`zero_std`), average weight-version staleness, eval tab. Opens on the newest
+  step that has samples, skipping one still being dumped; a step named in the
+  URL is always shown as asked.
 - **sample view** — a `conversation` tab (role-tagged turns with thinking /
   tool calls, from the trajectory sidecar) and a lazily-loaded `tokens` tab
   (the whole sequence in one scrollable metric-colored strip, opened at the

miles/dashboard/static/api.js

@@ -1,13 +1,13 @@
 const RETRIES_503 = 3;
 
-async function fetchOk(path, params) {
+async function fetchOk(path, params, { retry503 = true } = {}) {
   const url = new URL(path, location.origin);
   for (const [k, v] of Object.entries(params)) {
     if (v !== undefined && v !== null) url.searchParams.set(k, v);
   }
   for (let attempt = 0; ; attempt++) {
     const res = await fetch(url);
-    if (res.status === 503 && attempt < RETRIES_503) {
+    if (res.status === 503 && retry503 && attempt < RETRIES_503) {
       await new Promise((r) => setTimeout(r, 1500));
       continue;
     }
@@ -24,8 +24,8 @@ async function fetchOk(path, params) {
   }
 }
 
-export async function api(path, params = {}) {
-  return (await fetchOk(path, params)).json();
+export async function api(path, params = {}, options = {}) {
+  return (await fetchOk(path, params, options)).json();
 }
 
 // framed binary endpoints (/api/timeline/heatmap):

miles/dashboard/static/app.js

@@ -47,8 +47,14 @@ function parseRoute() {
     return { view: "timeline", lanes: params.get("lanes") };
   }
   if (segments[0] === "rollout" && segments.length >= 2) {
-    const rolloutId = Number(segments[1]);
     const evaluation = params.get("eval") === "1";
+    // "latest" is resolved against the dump at render time rather than baked
+    // into the link, because the newest step is often listed before it is
+    // readable; a typed step number is always honoured exactly
+    if (segments[1] === "latest") {
+      return { view: "rollout", rolloutId: null, evaluation };
+    }
+    const rolloutId = Number(segments[1]);
     if (segments[2] === "sample" && segments.length === 4) {
       return { view: "tokens", rolloutId, sampleIndex: Number(segments[3]), evaluation };
     }
@@ -58,18 +64,23 @@ function parseRoute() {
 }
 
 function crumbs(route, meta) {
-  const nav = (label, href, active) => el("a", { class: `nav${active ? " active" : ""}`, href }, [label]);
+  const nav = (label, href, active, onclick = null) =>
+    el("a", { class: `nav${active ? " active" : ""}`, href, onclick }, [label]);
   const parts = [nav("Metrics", "#/", route.view === "metrics")];
   if (meta.capabilities.has_timeline) {
     parts.push(nav("Compute Utilization", "#/timeline", route.view === "timeline"));
   }
   // the per-step data view is a top-level destination, not a hidden
-  // click-through from chart points; land on the newest train step
-  const latest = meta.rollout_ids.train.at(-1);
-  if (latest !== undefined) {
-    parts.push(nav("Rollouts", `#/rollout/${latest}`, route.view === "rollout" || route.view === "tokens"));
+  // click-through from chart points; land on the newest usable train step
+  if (meta.rollout_ids.train.length) {
+    const onRollout = route.view === "rollout" || route.view === "tokens";
+    const replaceInPlace = (event) => {
+      event.preventDefault();
+      location.replace("#/rollout/latest");
+    };
+    parts.push(nav("Rollouts", "#/rollout/latest", onRollout, onRollout ? replaceInPlace : null));
   }
-  if (route.view === "rollout" || route.view === "tokens") {
+  if ((route.view === "rollout" || route.view === "tokens") && route.rolloutId !== null) {
     const evalSuffix = route.evaluation ? "?eval=1" : "";
     parts.push(
       el("span", { class: "crumb" }, [

miles/dashboard/static/views_rollout.js

@@ -60,8 +60,50 @@ function sortableTable(rows, columns, { onRowClick, flagRow, sortState }) {
   return wrap;
 }
 
+// How far back the "latest" landing will look for a step it can actually show.
+// Anything deeper than this is not a fresh-dump race any more, so stopping lets
+// the real error surface instead of silently walking the reader into old data.
+const LANDING_LOOKBACK = 5;
+
+// The newest step is listed as soon as its dump file exists, which is earlier
+// than it can be read: the dump may still be mid-write (503), truncated, or
+// recorded with no samples at all. Land on the newest step that actually has
+// samples instead of on an error page.
+async function resolveLatest(ids, evaluation) {
+  for (const id of ids.slice(-LANDING_LOOKBACK).reverse()) {
+    try {
+      const summary = await api(`/api/rollout/${id}/summary`, { eval: evaluation }, { retry503: false });
+      if (summary.rows.length) return id;
+    } catch {
+      /* mid-write, truncated, or already rotated away: try the step before it */
+    }
+  }
+  // nothing readable nearby: go to the newest anyway so the reader sees the
+  // real error rather than a silent redirect into stale data
+  return ids.at(-1);
+}
+
 export async function renderRollout(view, meta, route) {
-  const { rolloutId, evaluation } = route;
+  const { evaluation } = route;
+  let { rolloutId } = route;
+  if (rolloutId === null) {
+    const candidates = evaluation ? meta.rollout_ids.eval : meta.rollout_ids.train;
+    if (!candidates.length) {
+      const kind = evaluation ? "eval" : "rollout";
+      view.replaceChildren(el("p", { class: "muted" }, [`No ${kind} steps have been dumped yet.`]));
+      return;
+    }
+    view.replaceChildren(el("p", { class: "muted" }, ["finding the newest step with data…"]));
+    const entryHash = location.hash;
+    rolloutId = await resolveLatest(candidates, evaluation);
+    // the resolve spans several requests; if the user navigated away in the
+    // meantime, rewriting the URL now would drag them back into this view
+    if (location.hash !== entryHash) return;
+    // rewrite the URL to the step actually shown, so reloads, Prev/Next and
+    // the breadcrumb all work off a real id
+    location.replace(`#/rollout/${rolloutId}${evaluation ? "?eval=1" : ""}`);
+    return;
+  }
   const [summary, groups] = await Promise.all([
     api(`/api/rollout/${rolloutId}/summary`, { eval: evaluation }),
     api(`/api/rollout/${rolloutId}/groups`, { eval: evaluation }),